Wikibooks plwikibooks https://pl.wikibooks.org/wiki/Wikibooks:Strona_g%C5%82%C3%B3wna MediaWiki 1.46.0-wmf.21 first-letter Media Specjalna Dyskusja Wikipedysta Dyskusja wikipedysty Wikibooks Dyskusja Wikibooks Plik Dyskusja pliku MediaWiki Dyskusja MediaWiki Szablon Dyskusja szablonu Pomoc Dyskusja pomocy Kategoria Dyskusja kategorii Wikijunior Dyskusja Wikijuniora TimedText TimedText talk Moduł Dyskusja modułu Wydarzenie Dyskusja wydarzenia 0 14142 538631 513399 2026-03-30T18:32:18Z Persino 2851 /* Druga zasada termodynamiki */ 538631 wikitext text/x-wiki <noinclude><!-- -->{{SkomplikowanaStronaStart<!-- -->| stopka strony = {{Kreska nawigacja|{{AktualnaKsiążka}}|{{NastępnyArtykuł}}|{{PoprzedniArtykuł}}}}<!-- -->}}</noinclude> Wprowadzimy zasady termodynamiki fenomenologicznej w sposób empiryczny, tzn. w sposób fenomenologiczny, nie wynikając w wewnetrzną strukturę, budowę układu czyli czy składa się z cząsteczek czy z atomów (w przypadku gazów szlachetnych). == Zerowa zasada termodynamiki == Zerową zasadę można opisać według prawa przechodności, tzn. jeśli układ termodynamiczny A jest w równowadze termodynamicznej z układem B, a układ C jest w równowadze z układem B, to układ A jest w równowadze termodynamicznym z układem C. Twierdzenie to mówi, że istnieje pojęcie temperatury, która określa tę równowagę. Przedstawiamy to za pomocą diagramu: {{CentrujWzór|<MATH>[(T_A \Leftrightarrow T_B) \wedge(T_B \Leftrightarrow T_C)] \Rightarrow (T_A \Leftrightarrow T_C)\;</MATH>|2.1}} == Pierwsza zasada termodynamiki == Pojęciem energii wewnętrznej nazywamy ilość energii zgromadzonej w ciele, poprzez wymianę energii w wyniku pracy lub dostarczenia ciepła. Nie można określić, ile jest w ciele energii wewnętrznej, natomiast można określić jej zmianę, tzn. {{Formuła|<MATH>\Delta U\;</MATH>}}. {{CentrujWzór|<MATH>dU=\delta Q+\delta W+\mu dN+\omega dt\;</MATH>|2.2}} * '''gdzie:''' * {{Formuła|<MATH>dU\;</MATH>}} - nieskończenie mała zmiana energii wewnętrznej, * {{Formuła|<MATH>\delta Q\;</MATH>}} - nieskończenie mała zmiana dostarczenia energii do ciała czyli ma znak plus, gdy {{Formuła|<MATH>\delta Q>0\;</MATH>}} dostarczano energię w postaci ciepła do układu, lub znak minus, gdy jest oddawana energia w tej samej postaci z rozważanego układu, * {{Formuła|<MATH>\delta W\;</MATH>}} - nieskończenie mała zmiana pracy wykonywanej nad układem, * {{Formuła|<MATH>\mu\;</MATH>}} - potencjał chemiczny, a {{Formuła|<MATH>dN\;</MATH>}} to bardzo mała zmiana liczby cząstek w układzie, ta stała jest związana, ile cząstek przybywa do układu od zewnątrz, wtedy {{Formuła|<MATH>dN>0\;</MATH>}}, w przeciwnym przypadku jest ujemne, lub przy braku tej wymiany zerowe, * {{Formuła|<MATH>\omega\;</MATH>}} - potencjał czasowy, a {{Formuła|<MATH>dt\;</MATH>}} to bardzo mała zmiana czasu układu, związany z reakcjami chemicznymi, czy jądrowymi, a nawet procesami wydzielania lub pochłonięcia się energii przy jakiś procesach fizycznych (mieszania się składników). A jak nie ma tego typu wymiany energii w układzie, to {{Formuła|<MATH>\omega=0</MATH>}}. A ogólniej tą zmienną (a właściwie funkcję) piszemy {{Formuła|<MATH>\omega=\omega(t)\;</MATH>}}, która ma postać zwykle funkcyjną. === Praca i ciepło === '''Ciepło''' jest to rodzaj energii, która jest wymieniana między układami termodynamicznymi, w celu osiągnięcia równowagi termodynamicznej. '''Praca''' jest to praca, która jest wykonywana przez siły zewnętrzne, w trakcie równowagi termodynamicznej, czyli w stanie quasistatycznym. W stanie równowagi, siły ciśnienia w gazie działają na ścianki naczynia z siłą: {{CentrujWzór|<MATH>\vec{F}_p=p\vec{S}\;</MATH>|2.3}} która jest równoważona przez siły zewnętrzne działająca na tłok, ponieważ zmiana objętości układu jest wykonana w czasie o przedziale nieskończenie dużym, a w praktyce w czasie bardzo dużym przedziale czasu, w którym podczas zmiany tej objętości przechodzimy przez poszczególne stany quasistacjonarne (stany które w przybliżeniu są stanami stacjonarnymi). A jeśli zmiana objętości jest wykonywana w nieskończonym czasie, tak by przy przejściu w tych stanach pośrednich układ przebywał w czasie nieskończenie dużym, w praktyce w czasie bardzo dużym, tak by stan przebywania w tych stanach był o wiele większy niż stany relaksacji tychże stanach pośrednich), którego siły zewnętrzne w naczyniu w zależności od sił ciśnienia działających na ściankę naczynia mają te same kierunki i wartości, ale przeciwne zwroty: {{CentrujWzór|<MATH>\vec{F}_z=-\vec{F}_p\;</MATH>|2.4}} Infinitezymalna praca wykonaną przez siły zewnętrzne {{LinkWzór|2.4}}, na podstawie definicji infitezymalnej pracy i definicji ciśnienia, co oznacza siłę działającej na powierzchnię S prostopadłą do tłoka pochodzącą od ciśnienia: {{CentrujWzór|<MATH>\delta W=\vec{F_z} d\vec{r}=-\vec{F_p}d\vec{r}=-p\vec{S}d\vec{r}=-pdV\;</MATH>|2.5}} Ze wzoru {{LinkWzór|2.5}} wynika wynikowe wyrażenie na infinitezymalną pracę podczas nieskończenie małej zmiany jego objętości przy ciśnieniu panujących w badanym układzie wynoszącej "p", jest ona wyrażona: {{CentrujWzór|<MATH> \delta W=-pdV\;</MATH>|2.6}} Określmy teraz nieskończenie małe ciepło dostarczone do układu znając temperaturę panującą w tym układzie, to z definicji infinitezymalnej zmiany entropii możemy wyprowadzić właśnie tą naszą wielkość, która zależy od temperatury bezwzględnej w układzie i od infinitezymalnej zmiany entropii panującej w naszym układzie: {{CentrujWzór|<MATH>dS={{\delta Q}\over{T}}\Rightarrow\delta Q=TdS\;</MATH>|2.7}} * '''gdzie:''' * {{Formuła|<MATH>dS\;</MATH>}} jest to zmiana entropii w ciele, * {{Formuła|<MATH>T\;</MATH>}} temperatura podczas tej zmiany. Jeśli przed daną wielkością występuje {{Formuła|<MATH>\delta\;</MATH>}}, to wtedy {{Formuła|<MATH>\delta K\;</MATH>}} nie jest różniczką zupełną, a jeśli {{Formuła|<MATH>d\;</MATH>}}, to wtedy {{Formuła|<MATH>d K\;</MATH>}} jest różniczką zupełną. Różniczką zupełną nazywamy taką różniczkę wielkości {{Formuła|<MATH>K\;</MATH>}}, jeśli da się przedstawić ona według równania: {{CentrujWzór|<MATH>dK=\sum^n_{p=1}\left({{\partial K}\over{\partial x_p}}\right)_{x_{i\neq p}}dx_p\;</MATH>|2.8}} * gdzie {{Formuła|<MATH>x_p\;</MATH>}}- parametr termodynamiczny o numerze "p" opisujący nasz badany układ. === Perpetuum mobile pierwszego rodzaju === Pierwszą zasadę termodynamiki można traktować jako zasadę zachowania energii. Mówi ona, że nie da się zbudować maszyny, która tworzy z niczego jakikolwiek energię. === Pełne sformułowanie pierwszej zasady termodynamiki === Bardzo mała zmiana energii wewnętrznej zależy od zmiany ciepła, która jest określana przez równość {{LinkWzór|2.7}} zależącą od temperatury panującej w układzie podczas wymiany nieskończenie małego ciepła i od infinitezymalnej zmianu wielkości ekstensywnej zwanej entropią w tym badanym obiekcie, a także od pracy wykonanej nad ciałem (układem) wykonanej przez siły zewnętrzne {{LinkWzór|2.6}} równoważącej siły pochodzące od ciśnienia panującej w gazie podczas jego działania na tłok, a także zależy od wymiany liczby cząstek, a także zależy od zmiany energii względem różniczki czasu, zatem korzystając z tychże wymienionych wzorów, to pierwszą zasadę termodynamiki można określić przez równanie: {{CentrujWzór|<MATH> dU=\delta Q-pdV+\mu dN+\omega dt=TdS-pdV+\mu dN+\omega dt\;</MATH>|2.9|Obramuj}} Korzystając z pierwszej zasady termodynamiki {{LinkWzór|2.2}} i wzoru {{LinkWzór|2.6}} otrzymujemy wyrażenie na infinitezymalną zmianę ciepła w zależności od bardzo małej zmiany energii wewnętrznej układu i wykonanej pracy w układzie podczas zmiany jego objętości: {{CentrujWzór|<MATH>\delta Q=dU-\delta W\Rightarrow\delta Q=dU+pdV-\mu dN-\omega dt\;</MATH>|2.10|Obramuj}} === Intuicyjne wyprowadzenie "Pierwszej zasady termodynamiki" === Zakładając, że ścianka naczynia z tłokiem jest idealnie gładka (zderzenia cząstek ze ściankami naczynia są całkowicie doskonałe), wtedy przesuwając tłok o bardzo małe przesunięcie {{Formuła|<MATH>d\vec{r}\;</MATH>}} zmieniamy objętość układu o infinitezymalną wartość {{Formuła|<MATH>dV\;</MATH>}}, wtedy zmiana energii wewnętrznej gazu jest równa pracy wykonanej przez układ wedle zasady zachowania energii, czyli wedle równania {{Formuła|<MATH>\delta W=-pdV\;</MATH>}}. Gdy ścianka nie jest idealnie gładka, wtedy poszczególne cząstki badanego danego układu podczas zderzeń ze ściankami dawane im jest ze strony ścianek, im ograniczających badanego układu, z części swojej energii kinetycznej z drgań i ruchu postępowego cząsteczek w ściankach, co wyrażane jest poprzez infinitezymalną zmianę entropii w temperaturze T w jakim układ się znajduje (zakładamy przy czym, że układ znajduje się w stanie równowagi termodynamicznej), a ciepło to jest wyrażone przez {{Formuła|<MATH>\delta Q=TdS</MATH>}}, cząstki mogą dochodzić do układu, co zwiększa wtedy jego energię o {{Formuła|<MATH>\mu dN\;</MATH>}}, a także energia w układzie może się wydzielać od wiązań chemicznych lub jądrowych, a nawet mieszania się składników, co zwiększa wtedy jego energię o {{Formuła|<MATH>\omega dt\;</MATH>}}, zsumując te energie otrzymujemy zmianę energii wewnętrznej, to na podstawie tego otrzymujemy wzór {{LinkWzór|2.2}}, który jest treścią pierwszej zasady termodynamiki fenomenologicznej. === Pierwsza zasada termodynamiki jako prawo przemiany energii === Dla procesów adiabatycznych, energia wymieniana na w sposób ciepła wynosi zero, czyli wiemy korzystając przy tym ze wzoru {{LinkWzór|2.7}} na infinitezymalną zmianę ciepła, że całka temperatury całkowaną względem entropii podczas omawianej przemiany wynosi z oczywistych powodów zero: {{CentrujWzór|<MATH>0=\Delta Q=\int TdS=\overline T\int dS\Rightarrow \int dS=0\Rightarrow \sum_i\delta S_i=0</MATH>|2.11}} Na podstawie wzoru {{LinkWzór|2.11}} zmiana entropii całego układu, która nie wymienia ciepła jest zero, na podstawie z twierdzenie średnich dla całek Riemanna, również podobne twierdzenie zachodzi dla sum dla różnic entropii o numerach {{Formuła|<MATH>i\;</MATH>}}. Wykorzystując {{LinkWzór|2.10}}, która omawia pierwszą zasadę termodynamiki, jeśli podczas naszego procesu zmiana ciepła jest zero, to wtedy ze względu, że energia wewnętrzna U posiada różniczkę zupełną energii wewnętrznej, to różniczka pracy, która w ogólności nie jest różniczką zupełną, w tym szczególnym przypadku dla naszej omawianej przemiany różniczka pracy jest różniczką zupełną. {{CentrujWzór|<MATH>\Delta U=\left(\Delta W\right)_{ad}</MATH>|2.12}} W tym przypadku można sformułować zasadę: : ''Dla procesów adiabatycznych zmiana stanu układu termodynamicznego wywołana jest przez pracę sił zewnętrznych niezależnych od sposobu w jakim ta zmiana jest wykonywana, czyli mamy równanie powiedziane {{LinkWzór|2.12}}, U posiada różniczkę zupełną i jest zależna od parametrów opisujących układ, wtedy różniczka pracy {{LinkWzór|2.6}} dla procesów adiabatycznych jest różniczką zupełną, bo zachodzi:'' {{CentrujWzór|<MATH>\Delta U=U_2-U_1=\int^2_1 dU=\int^2_1\delta W</MATH>|2.13}}'' == Druga zasada termodynamiki == Podamy różne sformułowania drugiej zasady termodynamiki: '''Sformułowanie Clausiusa''': :Niemożliwe jest przekazywanie ciepła od ciała o niższej temperaturze ciału o temperaturze wyższej bez wprowadzenia innych zmian w obu ciałach i ich otoczeniu. '''Sformułowanie Kelvina''': : Nie możliwe jest pobieranie ciepła z jednego źródła i zamianę go na pracę bez prowadzenia innych zmian w układzie i otoczeniu. Ogólnie zmiana entropii jest całką, przy którym z korzystamy ze wzoru {{LinkWzór|2.7}}, która jest napisana w zależności od infinitezymalnej zmiany ciepła wymienianego między układem a otoczeniem. Jeśli poszczególne zmiany infinitezymalne parametrów stanu są nałożone na pewną krzywą stanu układu, w którym mówiąc ogólnie jest zmiana temperatury, ale nie musi tak zachodzić, to wtedy całkowitą zmianę entropii między dwoma punktami końcowymi (punktem początkowym i końcowym, między dwoma stanami, w której ta zmiana jest wykonywana) jest określona jako całka infinitezymalnych entropii określająca dany pośredni stan między badanymi stanami krańcowymi, w którym ogólnie występuje zmiana temperatury: {{CentrujWzór|<MATH>\Delta S=\int\limits^{stan 2}_{stan 1}dS=\int\limits^{stan 2}_{stan 1} {{\delta Q}\over{T}}\;</MATH>|2.14}} Drugą zasadę termodynamiki, która określa, że całkowita zmiana entropii badanego układu nigdy nie maleje i którą można zapisać w postaci warunku: {{CentrujWzór|<MATH> \Delta S\geq 0\;</MATH>|2.15}} Dla układów termodynamicznych znak równości {{LinkWzór|2.15}} dotyczy procesów odwracalnych. Całkowita entropia układu określa całkowite nieuporządkowanie układu, a jego zmiana jest tak napisana, by nie zmniejszać nieuporządkowania (bałaganu) układu, którego badamy. ===Perpetuum mobile drugiego rodzaju=== Perpetuum mobile drugiego rodzaju - całe ciepło pobrane od ciała nie da się zamienić całkowicie na pracę, czyli musi być, że: {{CentrujWzór|<MATH> \delta Q \ne dW\;</MATH>|2.16}} == Trzecia zasada termodynamiki == Według trzeciej zasady termodynamiki mamy, że entropia i ciepło właściwe znikają w temperaturze T=0. Podczas przemian fizycznych, nigdy nie można dojść to temperatury T=0, a jedynie do bardzo jej bliskiego dodatniego otoczenia, ponieważ ciepło substancji maleje asymptotycznie do zera. == Wyprowadzenie "Zerowej zasady termodynamiki" == Podzielmy nasz układ na n części, najlepiej by liczba tych części była liczbą nieskończenie dużą lub prawie nieskończoną, by poszczególne podukłady były infinitezymalnie małe, na tyle małe by w takiej cząstce znajdowała się na tyle dużo cząstek by prawa termodynamiki były spełnione, chodzi tutaj o wzór na infinitezymalną pracę i o drugą zasadę termodynamiki. Wiemy jednak, że całkowita zmiana energii wewnętrznej dla n podukładów jest niezmienna z zasady zachowania energii całego układu i wynosi zero: {{CentrujWzór|<MATH>\sum^n_{i=1}dU_i=0\;</MATH>|2.17}} Wiadomo, że objętość całego układu jest niezmienna i jej zmiana w zależności od zmian objętości w poszczególnych częściach tego układu jest zero (tzn.: sumaryczna zmiana objętości całego układu jako zmiany poszczególnych jej składników jest równa zero): {{CentrujWzór|<MATH>\sum^n_{i=1}dV_i=0\;</MATH>|2.18}} Zmiana cząstek układu danej substancji i fazy jest równa zero w układzie zamkniętym: {{CentrujWzór|<MATH>\sum^n_{i=1}dN_i=0\;</MATH>|2.18a}} Rozpatrujemy układ w danym czasie statystycznym, mówiąc: {{CentrujWzór|<MATH>dt_i=dt=0\;</MATH>|2.18b}} Z pierwszej zasady termodynamiki wiadomo mamy wzór {{LinkWzór|2.2}}, a także mamy wzór na infinitezymalną wykonaną pracę poprzez infinitezymalną zmianę jej objętości {{LinkWzór|2.6}}, oraz ciśnienie w całym układzie jest niezależne od punktu, w którym układ jest badamy i jest stałe dla całego układu (bo układ jest w stanie równowagi mechanicznej, tzn. poszczególne składniki, punktu układu, są w spoczynku wedle drugiej zasady dynamiki Newtona), korzystamy tutaj ze wzoru {{LinkWzór|2.17}}, także z warunku na zmianę objętości całego układu {{LinkWzór|2.18}}, zatem zmiana energii wewnętrznej całego układu jest określona przy pomocy zmian energii na w sposób ciepła między poszczególnymi podukładami: {{CentrujWzór|<MATH>0=\sum^n_{i=1}dU_i=\sum^n_{i=1}\left(\delta Q_i+pdV_i+\mu_i dN_i+\omega_i dt_i\right)= \sum^n_{i=1}\delta Q_i+p\sum^n_{i=1}dV_i+\sum^n_{i=1}\mu_i dN_i+\sum^n_{i=1}\omega_i dt_i=\sum^n_{i=1}\delta Q_i</MATH>|2.19}} Z równania {{LinkWzór|2.19}} otrzymujemy rezultat, że całkowite ciepło wymieniane między różnymi podukładami w układzie termodynamicznym jest równe zero: {{CentrujWzór|<MATH>\sum^n_{i=1}\delta Q_i=0\;</MATH>|2.20}} Podzielmy obie strony równania {{LinkWzór|2.20}} przez stałą C o wymiarze temperatury, wtedy otrzymujemy inne równoważne równanie, bo mamy tutaj zawsze, że stała C jest nierówna zero z definicji: {{CentrujWzór|<MATH>\sum^n_{i=1}{{\delta Q_i}\over{C}}=0\;</MATH>|2.21}} Z drugiej zasady termodynamiki {{LinkWzór|2.15}} dla układów odwracalnych całkowita entropia całego układu jest sumą infinitezymalnych zmian entropii różnych podukładów i jako całość nie zmienia się: {{CentrujWzór|<MATH>0=\sum^n_{i=1}{{\delta Q_i}\over{T_i}}\;</MATH>|2.22}} Odejmijmy równanie {{LinkWzór|2.22}} od wzoru {{LinkWzór|2.21}}, stąd dostajemy: {{CentrujWzór|<MATH>\sum^n_{i=1}\left({{1}\over{C}}-{{1}\over{T_i}}\right)\delta Q_i=0\;</MATH>|2.23}} Równanie {{LinkWzór|2.23}} jest spełnione dla dowolnego ciepła przekazywanej między różnymi podukładami, wtedy: {{CentrujWzór|<MATH>{{1}\over{C}}-{{1}\over{T_i}}=0\Rightarrow C=T_i\;</MATH>|2.24}} Stała {{Formuła|<MATH>C\;</MATH>}} jest niezależna od rodzaju układów i od numeru "i", zatem dochodzimy do wniosku, że temperatura całego układu jest stała i jest taka sama, niezależna od numeru podukładu, w którym ta temperatura obowiązuje, ani od zmiany objętości poszczególnych podukładów, czyli: {{CentrujWzór|<MATH>T=C=T_1=T_2=...=T_n\;</MATH>|2.25}} Z {{LinkWzór|2.25}} z pierwszej i drugiej zasady termodynamiki w stanie równowagi termodynamicznej dla układów odwracalnych wynika zerowa zasada termodynamiki, czyli ta zasada została udowodniona na podstawie pierwszej i drugiej zasady termodynamiki (przemiany quasistatyczny) i równowagi mechanicznej poszczególnych cząstek (podukładów) w całym wielkim układzie. <noinclude>{{SkomplikowanaStronaKoniec}}</noinclude> l114s0tw8hr2yqk9pfuug9b1x8khc2d 538632 538631 2026-03-30T18:37:14Z Persino 2851 /* Druga zasada termodynamiki */ 538632 wikitext text/x-wiki <noinclude><!-- -->{{SkomplikowanaStronaStart<!-- -->| stopka strony = {{Kreska nawigacja|{{AktualnaKsiążka}}|{{NastępnyArtykuł}}|{{PoprzedniArtykuł}}}}<!-- -->}}</noinclude> Wprowadzimy zasady termodynamiki fenomenologicznej w sposób empiryczny, tzn. w sposób fenomenologiczny, nie wynikając w wewnetrzną strukturę, budowę układu czyli czy składa się z cząsteczek czy z atomów (w przypadku gazów szlachetnych). == Zerowa zasada termodynamiki == Zerową zasadę można opisać według prawa przechodności, tzn. jeśli układ termodynamiczny A jest w równowadze termodynamicznej z układem B, a układ C jest w równowadze z układem B, to układ A jest w równowadze termodynamicznym z układem C. Twierdzenie to mówi, że istnieje pojęcie temperatury, która określa tę równowagę. Przedstawiamy to za pomocą diagramu: {{CentrujWzór|<MATH>[(T_A \Leftrightarrow T_B) \wedge(T_B \Leftrightarrow T_C)] \Rightarrow (T_A \Leftrightarrow T_C)\;</MATH>|2.1}} == Pierwsza zasada termodynamiki == Pojęciem energii wewnętrznej nazywamy ilość energii zgromadzonej w ciele, poprzez wymianę energii w wyniku pracy lub dostarczenia ciepła. Nie można określić, ile jest w ciele energii wewnętrznej, natomiast można określić jej zmianę, tzn. {{Formuła|<MATH>\Delta U\;</MATH>}}. {{CentrujWzór|<MATH>dU=\delta Q+\delta W+\mu dN+\omega dt\;</MATH>|2.2}} * '''gdzie:''' * {{Formuła|<MATH>dU\;</MATH>}} - nieskończenie mała zmiana energii wewnętrznej, * {{Formuła|<MATH>\delta Q\;</MATH>}} - nieskończenie mała zmiana dostarczenia energii do ciała czyli ma znak plus, gdy {{Formuła|<MATH>\delta Q>0\;</MATH>}} dostarczano energię w postaci ciepła do układu, lub znak minus, gdy jest oddawana energia w tej samej postaci z rozważanego układu, * {{Formuła|<MATH>\delta W\;</MATH>}} - nieskończenie mała zmiana pracy wykonywanej nad układem, * {{Formuła|<MATH>\mu\;</MATH>}} - potencjał chemiczny, a {{Formuła|<MATH>dN\;</MATH>}} to bardzo mała zmiana liczby cząstek w układzie, ta stała jest związana, ile cząstek przybywa do układu od zewnątrz, wtedy {{Formuła|<MATH>dN>0\;</MATH>}}, w przeciwnym przypadku jest ujemne, lub przy braku tej wymiany zerowe, * {{Formuła|<MATH>\omega\;</MATH>}} - potencjał czasowy, a {{Formuła|<MATH>dt\;</MATH>}} to bardzo mała zmiana czasu układu, związany z reakcjami chemicznymi, czy jądrowymi, a nawet procesami wydzielania lub pochłonięcia się energii przy jakiś procesach fizycznych (mieszania się składników). A jak nie ma tego typu wymiany energii w układzie, to {{Formuła|<MATH>\omega=0</MATH>}}. A ogólniej tą zmienną (a właściwie funkcję) piszemy {{Formuła|<MATH>\omega=\omega(t)\;</MATH>}}, która ma postać zwykle funkcyjną. === Praca i ciepło === '''Ciepło''' jest to rodzaj energii, która jest wymieniana między układami termodynamicznymi, w celu osiągnięcia równowagi termodynamicznej. '''Praca''' jest to praca, która jest wykonywana przez siły zewnętrzne, w trakcie równowagi termodynamicznej, czyli w stanie quasistatycznym. W stanie równowagi, siły ciśnienia w gazie działają na ścianki naczynia z siłą: {{CentrujWzór|<MATH>\vec{F}_p=p\vec{S}\;</MATH>|2.3}} która jest równoważona przez siły zewnętrzne działająca na tłok, ponieważ zmiana objętości układu jest wykonana w czasie o przedziale nieskończenie dużym, a w praktyce w czasie bardzo dużym przedziale czasu, w którym podczas zmiany tej objętości przechodzimy przez poszczególne stany quasistacjonarne (stany które w przybliżeniu są stanami stacjonarnymi). A jeśli zmiana objętości jest wykonywana w nieskończonym czasie, tak by przy przejściu w tych stanach pośrednich układ przebywał w czasie nieskończenie dużym, w praktyce w czasie bardzo dużym, tak by stan przebywania w tych stanach był o wiele większy niż stany relaksacji tychże stanach pośrednich), którego siły zewnętrzne w naczyniu w zależności od sił ciśnienia działających na ściankę naczynia mają te same kierunki i wartości, ale przeciwne zwroty: {{CentrujWzór|<MATH>\vec{F}_z=-\vec{F}_p\;</MATH>|2.4}} Infinitezymalna praca wykonaną przez siły zewnętrzne {{LinkWzór|2.4}}, na podstawie definicji infitezymalnej pracy i definicji ciśnienia, co oznacza siłę działającej na powierzchnię S prostopadłą do tłoka pochodzącą od ciśnienia: {{CentrujWzór|<MATH>\delta W=\vec{F_z} d\vec{r}=-\vec{F_p}d\vec{r}=-p\vec{S}d\vec{r}=-pdV\;</MATH>|2.5}} Ze wzoru {{LinkWzór|2.5}} wynika wynikowe wyrażenie na infinitezymalną pracę podczas nieskończenie małej zmiany jego objętości przy ciśnieniu panujących w badanym układzie wynoszącej "p", jest ona wyrażona: {{CentrujWzór|<MATH> \delta W=-pdV\;</MATH>|2.6}} Określmy teraz nieskończenie małe ciepło dostarczone do układu znając temperaturę panującą w tym układzie, to z definicji infinitezymalnej zmiany entropii możemy wyprowadzić właśnie tą naszą wielkość, która zależy od temperatury bezwzględnej w układzie i od infinitezymalnej zmiany entropii panującej w naszym układzie: {{CentrujWzór|<MATH>dS={{\delta Q}\over{T}}\Rightarrow\delta Q=TdS\;</MATH>|2.7}} * '''gdzie:''' * {{Formuła|<MATH>dS\;</MATH>}} jest to zmiana entropii w ciele, * {{Formuła|<MATH>T\;</MATH>}} temperatura podczas tej zmiany. Jeśli przed daną wielkością występuje {{Formuła|<MATH>\delta\;</MATH>}}, to wtedy {{Formuła|<MATH>\delta K\;</MATH>}} nie jest różniczką zupełną, a jeśli {{Formuła|<MATH>d\;</MATH>}}, to wtedy {{Formuła|<MATH>d K\;</MATH>}} jest różniczką zupełną. Różniczką zupełną nazywamy taką różniczkę wielkości {{Formuła|<MATH>K\;</MATH>}}, jeśli da się przedstawić ona według równania: {{CentrujWzór|<MATH>dK=\sum^n_{p=1}\left({{\partial K}\over{\partial x_p}}\right)_{x_{i\neq p}}dx_p\;</MATH>|2.8}} * gdzie {{Formuła|<MATH>x_p\;</MATH>}}- parametr termodynamiczny o numerze "p" opisujący nasz badany układ. === Perpetuum mobile pierwszego rodzaju === Pierwszą zasadę termodynamiki można traktować jako zasadę zachowania energii. Mówi ona, że nie da się zbudować maszyny, która tworzy z niczego jakikolwiek energię. === Pełne sformułowanie pierwszej zasady termodynamiki === Bardzo mała zmiana energii wewnętrznej zależy od zmiany ciepła, która jest określana przez równość {{LinkWzór|2.7}} zależącą od temperatury panującej w układzie podczas wymiany nieskończenie małego ciepła i od infinitezymalnej zmianu wielkości ekstensywnej zwanej entropią w tym badanym obiekcie, a także od pracy wykonanej nad ciałem (układem) wykonanej przez siły zewnętrzne {{LinkWzór|2.6}} równoważącej siły pochodzące od ciśnienia panującej w gazie podczas jego działania na tłok, a także zależy od wymiany liczby cząstek, a także zależy od zmiany energii względem różniczki czasu, zatem korzystając z tychże wymienionych wzorów, to pierwszą zasadę termodynamiki można określić przez równanie: {{CentrujWzór|<MATH> dU=\delta Q-pdV+\mu dN+\omega dt=TdS-pdV+\mu dN+\omega dt\;</MATH>|2.9|Obramuj}} Korzystając z pierwszej zasady termodynamiki {{LinkWzór|2.2}} i wzoru {{LinkWzór|2.6}} otrzymujemy wyrażenie na infinitezymalną zmianę ciepła w zależności od bardzo małej zmiany energii wewnętrznej układu i wykonanej pracy w układzie podczas zmiany jego objętości: {{CentrujWzór|<MATH>\delta Q=dU-\delta W\Rightarrow\delta Q=dU+pdV-\mu dN-\omega dt\;</MATH>|2.10|Obramuj}} === Intuicyjne wyprowadzenie "Pierwszej zasady termodynamiki" === Zakładając, że ścianka naczynia z tłokiem jest idealnie gładka (zderzenia cząstek ze ściankami naczynia są całkowicie doskonałe), wtedy przesuwając tłok o bardzo małe przesunięcie {{Formuła|<MATH>d\vec{r}\;</MATH>}} zmieniamy objętość układu o infinitezymalną wartość {{Formuła|<MATH>dV\;</MATH>}}, wtedy zmiana energii wewnętrznej gazu jest równa pracy wykonanej przez układ wedle zasady zachowania energii, czyli wedle równania {{Formuła|<MATH>\delta W=-pdV\;</MATH>}}. Gdy ścianka nie jest idealnie gładka, wtedy poszczególne cząstki badanego danego układu podczas zderzeń ze ściankami dawane im jest ze strony ścianek, im ograniczających badanego układu, z części swojej energii kinetycznej z drgań i ruchu postępowego cząsteczek w ściankach, co wyrażane jest poprzez infinitezymalną zmianę entropii w temperaturze T w jakim układ się znajduje (zakładamy przy czym, że układ znajduje się w stanie równowagi termodynamicznej), a ciepło to jest wyrażone przez {{Formuła|<MATH>\delta Q=TdS</MATH>}}, cząstki mogą dochodzić do układu, co zwiększa wtedy jego energię o {{Formuła|<MATH>\mu dN\;</MATH>}}, a także energia w układzie może się wydzielać od wiązań chemicznych lub jądrowych, a nawet mieszania się składników, co zwiększa wtedy jego energię o {{Formuła|<MATH>\omega dt\;</MATH>}}, zsumując te energie otrzymujemy zmianę energii wewnętrznej, to na podstawie tego otrzymujemy wzór {{LinkWzór|2.2}}, który jest treścią pierwszej zasady termodynamiki fenomenologicznej. === Pierwsza zasada termodynamiki jako prawo przemiany energii === Dla procesów adiabatycznych, energia wymieniana na w sposób ciepła wynosi zero, czyli wiemy korzystając przy tym ze wzoru {{LinkWzór|2.7}} na infinitezymalną zmianę ciepła, że całka temperatury całkowaną względem entropii podczas omawianej przemiany wynosi z oczywistych powodów zero: {{CentrujWzór|<MATH>0=\Delta Q=\int TdS=\overline T\int dS\Rightarrow \int dS=0\Rightarrow \sum_i\delta S_i=0</MATH>|2.11}} Na podstawie wzoru {{LinkWzór|2.11}} zmiana entropii całego układu, która nie wymienia ciepła jest zero, na podstawie z twierdzenie średnich dla całek Riemanna, również podobne twierdzenie zachodzi dla sum dla różnic entropii o numerach {{Formuła|<MATH>i\;</MATH>}}. Wykorzystując {{LinkWzór|2.10}}, która omawia pierwszą zasadę termodynamiki, jeśli podczas naszego procesu zmiana ciepła jest zero, to wtedy ze względu, że energia wewnętrzna U posiada różniczkę zupełną energii wewnętrznej, to różniczka pracy, która w ogólności nie jest różniczką zupełną, w tym szczególnym przypadku dla naszej omawianej przemiany różniczka pracy jest różniczką zupełną. {{CentrujWzór|<MATH>\Delta U=\left(\Delta W\right)_{ad}</MATH>|2.12}} W tym przypadku można sformułować zasadę: : ''Dla procesów adiabatycznych zmiana stanu układu termodynamicznego wywołana jest przez pracę sił zewnętrznych niezależnych od sposobu w jakim ta zmiana jest wykonywana, czyli mamy równanie powiedziane {{LinkWzór|2.12}}, U posiada różniczkę zupełną i jest zależna od parametrów opisujących układ, wtedy różniczka pracy {{LinkWzór|2.6}} dla procesów adiabatycznych jest różniczką zupełną, bo zachodzi:'' {{CentrujWzór|<MATH>\Delta U=U_2-U_1=\int^2_1 dU=\int^2_1\delta W</MATH>|2.13}}'' == Druga zasada termodynamiki == Podamy różne sformułowania drugiej zasady termodynamiki: '''Sformułowanie Clausiusa''': :Niemożliwe jest przekazywanie ciepła od ciała o niższej temperaturze ciału o temperaturze wyższej bez wprowadzenia innych zmian w obu ciałach i ich otoczeniu. '''Sformułowanie Kelvina''': : Nie możliwe jest pobieranie ciepła z jednego źródła i zamianę go na pracę bez prowadzenia innych zmian w układzie i otoczeniu. Ogólnie zmiana entropii jest całką, przy którym z korzystamy ze wzoru {{LinkWzór|2.7}}, która jest napisana w zależności od infinitezymalnej zmiany ciepła wymienianego między układem a otoczeniem. Jeśli poszczególne zmiany infinitezymalne parametrów stanu są nałożone na pewną krzywą stanu układu, w którym mówiąc ogólnie jest zmiana temperatury, ale nie musi tak zachodzić, to wtedy całkowitą zmianę entropii między dwoma punktami końcowymi (punktem początkowym i końcowym, między dwoma stanami, w której ta zmiana jest wykonywana) jest określona jako całka infinitezymalnych entropii określająca dany pośredni stan między badanymi stanami krańcowymi, w którym ogólnie występuje zmiana temperatury: {{CentrujWzór|<MATH>\Delta S=\int\limits^{stan 2}_{stan 1}dS=\int\limits^{stan 2}_{stan 1} {{\delta Q}\over{T}}\;</MATH>|2.14}} Drugą zasadę termodynamiki, która określa, że całkowita zmiana entropii badanego układu nigdy nie maleje i którą można zapisać w postaci warunku: {{CentrujWzór|<MATH> \Delta S\geq 0\;</MATH>|2.15}} Dla układów termodynamicznych znak równości {{LinkWzór|2.15}} dotyczy procesów odwracalnych. Całkowita entropia układu określa całkowite nieuporządkowanie układu, a jego zmiana jest tak napisana, by nie zmniejszać nieuporządkowania (bałaganu) układu, którego badamy, chociaż potocznie by się wydawało być odwrotnie, tzn. czy jest większy porządek na początku wszechświata, czy teraz, by się wydawało, że teraz, a w fizyce tak już nie jest, w fizyce jest odwrotnie niż według potocznego punktu widzenia. ===Perpetuum mobile drugiego rodzaju=== Perpetuum mobile drugiego rodzaju - całe ciepło pobrane od ciała nie da się zamienić całkowicie na pracę, czyli musi być, że: {{CentrujWzór|<MATH> \delta Q \ne dW\;</MATH>|2.16}} == Trzecia zasada termodynamiki == Według trzeciej zasady termodynamiki mamy, że entropia i ciepło właściwe znikają w temperaturze T=0. Podczas przemian fizycznych, nigdy nie można dojść to temperatury T=0, a jedynie do bardzo jej bliskiego dodatniego otoczenia, ponieważ ciepło substancji maleje asymptotycznie do zera. == Wyprowadzenie "Zerowej zasady termodynamiki" == Podzielmy nasz układ na n części, najlepiej by liczba tych części była liczbą nieskończenie dużą lub prawie nieskończoną, by poszczególne podukłady były infinitezymalnie małe, na tyle małe by w takiej cząstce znajdowała się na tyle dużo cząstek by prawa termodynamiki były spełnione, chodzi tutaj o wzór na infinitezymalną pracę i o drugą zasadę termodynamiki. Wiemy jednak, że całkowita zmiana energii wewnętrznej dla n podukładów jest niezmienna z zasady zachowania energii całego układu i wynosi zero: {{CentrujWzór|<MATH>\sum^n_{i=1}dU_i=0\;</MATH>|2.17}} Wiadomo, że objętość całego układu jest niezmienna i jej zmiana w zależności od zmian objętości w poszczególnych częściach tego układu jest zero (tzn.: sumaryczna zmiana objętości całego układu jako zmiany poszczególnych jej składników jest równa zero): {{CentrujWzór|<MATH>\sum^n_{i=1}dV_i=0\;</MATH>|2.18}} Zmiana cząstek układu danej substancji i fazy jest równa zero w układzie zamkniętym: {{CentrujWzór|<MATH>\sum^n_{i=1}dN_i=0\;</MATH>|2.18a}} Rozpatrujemy układ w danym czasie statystycznym, mówiąc: {{CentrujWzór|<MATH>dt_i=dt=0\;</MATH>|2.18b}} Z pierwszej zasady termodynamiki wiadomo mamy wzór {{LinkWzór|2.2}}, a także mamy wzór na infinitezymalną wykonaną pracę poprzez infinitezymalną zmianę jej objętości {{LinkWzór|2.6}}, oraz ciśnienie w całym układzie jest niezależne od punktu, w którym układ jest badamy i jest stałe dla całego układu (bo układ jest w stanie równowagi mechanicznej, tzn. poszczególne składniki, punktu układu, są w spoczynku wedle drugiej zasady dynamiki Newtona), korzystamy tutaj ze wzoru {{LinkWzór|2.17}}, także z warunku na zmianę objętości całego układu {{LinkWzór|2.18}}, zatem zmiana energii wewnętrznej całego układu jest określona przy pomocy zmian energii na w sposób ciepła między poszczególnymi podukładami: {{CentrujWzór|<MATH>0=\sum^n_{i=1}dU_i=\sum^n_{i=1}\left(\delta Q_i+pdV_i+\mu_i dN_i+\omega_i dt_i\right)= \sum^n_{i=1}\delta Q_i+p\sum^n_{i=1}dV_i+\sum^n_{i=1}\mu_i dN_i+\sum^n_{i=1}\omega_i dt_i=\sum^n_{i=1}\delta Q_i</MATH>|2.19}} Z równania {{LinkWzór|2.19}} otrzymujemy rezultat, że całkowite ciepło wymieniane między różnymi podukładami w układzie termodynamicznym jest równe zero: {{CentrujWzór|<MATH>\sum^n_{i=1}\delta Q_i=0\;</MATH>|2.20}} Podzielmy obie strony równania {{LinkWzór|2.20}} przez stałą C o wymiarze temperatury, wtedy otrzymujemy inne równoważne równanie, bo mamy tutaj zawsze, że stała C jest nierówna zero z definicji: {{CentrujWzór|<MATH>\sum^n_{i=1}{{\delta Q_i}\over{C}}=0\;</MATH>|2.21}} Z drugiej zasady termodynamiki {{LinkWzór|2.15}} dla układów odwracalnych całkowita entropia całego układu jest sumą infinitezymalnych zmian entropii różnych podukładów i jako całość nie zmienia się: {{CentrujWzór|<MATH>0=\sum^n_{i=1}{{\delta Q_i}\over{T_i}}\;</MATH>|2.22}} Odejmijmy równanie {{LinkWzór|2.22}} od wzoru {{LinkWzór|2.21}}, stąd dostajemy: {{CentrujWzór|<MATH>\sum^n_{i=1}\left({{1}\over{C}}-{{1}\over{T_i}}\right)\delta Q_i=0\;</MATH>|2.23}} Równanie {{LinkWzór|2.23}} jest spełnione dla dowolnego ciepła przekazywanej między różnymi podukładami, wtedy: {{CentrujWzór|<MATH>{{1}\over{C}}-{{1}\over{T_i}}=0\Rightarrow C=T_i\;</MATH>|2.24}} Stała {{Formuła|<MATH>C\;</MATH>}} jest niezależna od rodzaju układów i od numeru "i", zatem dochodzimy do wniosku, że temperatura całego układu jest stała i jest taka sama, niezależna od numeru podukładu, w którym ta temperatura obowiązuje, ani od zmiany objętości poszczególnych podukładów, czyli: {{CentrujWzór|<MATH>T=C=T_1=T_2=...=T_n\;</MATH>|2.25}} Z {{LinkWzór|2.25}} z pierwszej i drugiej zasady termodynamiki w stanie równowagi termodynamicznej dla układów odwracalnych wynika zerowa zasada termodynamiki, czyli ta zasada została udowodniona na podstawie pierwszej i drugiej zasady termodynamiki (przemiany quasistatyczny) i równowagi mechanicznej poszczególnych cząstek (podukładów) w całym wielkim układzie. <noinclude>{{SkomplikowanaStronaKoniec}}</noinclude> grp2ng32g9i2iwqjge3u92vau0g6np2 538633 538632 2026-03-30T18:40:42Z Persino 2851 /* Perpetuum mobile drugiego rodzaju */ 538633 wikitext text/x-wiki <noinclude><!-- -->{{SkomplikowanaStronaStart<!-- -->| stopka strony = {{Kreska nawigacja|{{AktualnaKsiążka}}|{{NastępnyArtykuł}}|{{PoprzedniArtykuł}}}}<!-- -->}}</noinclude> Wprowadzimy zasady termodynamiki fenomenologicznej w sposób empiryczny, tzn. w sposób fenomenologiczny, nie wynikając w wewnetrzną strukturę, budowę układu czyli czy składa się z cząsteczek czy z atomów (w przypadku gazów szlachetnych). == Zerowa zasada termodynamiki == Zerową zasadę można opisać według prawa przechodności, tzn. jeśli układ termodynamiczny A jest w równowadze termodynamicznej z układem B, a układ C jest w równowadze z układem B, to układ A jest w równowadze termodynamicznym z układem C. Twierdzenie to mówi, że istnieje pojęcie temperatury, która określa tę równowagę. Przedstawiamy to za pomocą diagramu: {{CentrujWzór|<MATH>[(T_A \Leftrightarrow T_B) \wedge(T_B \Leftrightarrow T_C)] \Rightarrow (T_A \Leftrightarrow T_C)\;</MATH>|2.1}} == Pierwsza zasada termodynamiki == Pojęciem energii wewnętrznej nazywamy ilość energii zgromadzonej w ciele, poprzez wymianę energii w wyniku pracy lub dostarczenia ciepła. Nie można określić, ile jest w ciele energii wewnętrznej, natomiast można określić jej zmianę, tzn. {{Formuła|<MATH>\Delta U\;</MATH>}}. {{CentrujWzór|<MATH>dU=\delta Q+\delta W+\mu dN+\omega dt\;</MATH>|2.2}} * '''gdzie:''' * {{Formuła|<MATH>dU\;</MATH>}} - nieskończenie mała zmiana energii wewnętrznej, * {{Formuła|<MATH>\delta Q\;</MATH>}} - nieskończenie mała zmiana dostarczenia energii do ciała czyli ma znak plus, gdy {{Formuła|<MATH>\delta Q>0\;</MATH>}} dostarczano energię w postaci ciepła do układu, lub znak minus, gdy jest oddawana energia w tej samej postaci z rozważanego układu, * {{Formuła|<MATH>\delta W\;</MATH>}} - nieskończenie mała zmiana pracy wykonywanej nad układem, * {{Formuła|<MATH>\mu\;</MATH>}} - potencjał chemiczny, a {{Formuła|<MATH>dN\;</MATH>}} to bardzo mała zmiana liczby cząstek w układzie, ta stała jest związana, ile cząstek przybywa do układu od zewnątrz, wtedy {{Formuła|<MATH>dN>0\;</MATH>}}, w przeciwnym przypadku jest ujemne, lub przy braku tej wymiany zerowe, * {{Formuła|<MATH>\omega\;</MATH>}} - potencjał czasowy, a {{Formuła|<MATH>dt\;</MATH>}} to bardzo mała zmiana czasu układu, związany z reakcjami chemicznymi, czy jądrowymi, a nawet procesami wydzielania lub pochłonięcia się energii przy jakiś procesach fizycznych (mieszania się składników). A jak nie ma tego typu wymiany energii w układzie, to {{Formuła|<MATH>\omega=0</MATH>}}. A ogólniej tą zmienną (a właściwie funkcję) piszemy {{Formuła|<MATH>\omega=\omega(t)\;</MATH>}}, która ma postać zwykle funkcyjną. === Praca i ciepło === '''Ciepło''' jest to rodzaj energii, która jest wymieniana między układami termodynamicznymi, w celu osiągnięcia równowagi termodynamicznej. '''Praca''' jest to praca, która jest wykonywana przez siły zewnętrzne, w trakcie równowagi termodynamicznej, czyli w stanie quasistatycznym. W stanie równowagi, siły ciśnienia w gazie działają na ścianki naczynia z siłą: {{CentrujWzór|<MATH>\vec{F}_p=p\vec{S}\;</MATH>|2.3}} która jest równoważona przez siły zewnętrzne działająca na tłok, ponieważ zmiana objętości układu jest wykonana w czasie o przedziale nieskończenie dużym, a w praktyce w czasie bardzo dużym przedziale czasu, w którym podczas zmiany tej objętości przechodzimy przez poszczególne stany quasistacjonarne (stany które w przybliżeniu są stanami stacjonarnymi). A jeśli zmiana objętości jest wykonywana w nieskończonym czasie, tak by przy przejściu w tych stanach pośrednich układ przebywał w czasie nieskończenie dużym, w praktyce w czasie bardzo dużym, tak by stan przebywania w tych stanach był o wiele większy niż stany relaksacji tychże stanach pośrednich), którego siły zewnętrzne w naczyniu w zależności od sił ciśnienia działających na ściankę naczynia mają te same kierunki i wartości, ale przeciwne zwroty: {{CentrujWzór|<MATH>\vec{F}_z=-\vec{F}_p\;</MATH>|2.4}} Infinitezymalna praca wykonaną przez siły zewnętrzne {{LinkWzór|2.4}}, na podstawie definicji infitezymalnej pracy i definicji ciśnienia, co oznacza siłę działającej na powierzchnię S prostopadłą do tłoka pochodzącą od ciśnienia: {{CentrujWzór|<MATH>\delta W=\vec{F_z} d\vec{r}=-\vec{F_p}d\vec{r}=-p\vec{S}d\vec{r}=-pdV\;</MATH>|2.5}} Ze wzoru {{LinkWzór|2.5}} wynika wynikowe wyrażenie na infinitezymalną pracę podczas nieskończenie małej zmiany jego objętości przy ciśnieniu panujących w badanym układzie wynoszącej "p", jest ona wyrażona: {{CentrujWzór|<MATH> \delta W=-pdV\;</MATH>|2.6}} Określmy teraz nieskończenie małe ciepło dostarczone do układu znając temperaturę panującą w tym układzie, to z definicji infinitezymalnej zmiany entropii możemy wyprowadzić właśnie tą naszą wielkość, która zależy od temperatury bezwzględnej w układzie i od infinitezymalnej zmiany entropii panującej w naszym układzie: {{CentrujWzór|<MATH>dS={{\delta Q}\over{T}}\Rightarrow\delta Q=TdS\;</MATH>|2.7}} * '''gdzie:''' * {{Formuła|<MATH>dS\;</MATH>}} jest to zmiana entropii w ciele, * {{Formuła|<MATH>T\;</MATH>}} temperatura podczas tej zmiany. Jeśli przed daną wielkością występuje {{Formuła|<MATH>\delta\;</MATH>}}, to wtedy {{Formuła|<MATH>\delta K\;</MATH>}} nie jest różniczką zupełną, a jeśli {{Formuła|<MATH>d\;</MATH>}}, to wtedy {{Formuła|<MATH>d K\;</MATH>}} jest różniczką zupełną. Różniczką zupełną nazywamy taką różniczkę wielkości {{Formuła|<MATH>K\;</MATH>}}, jeśli da się przedstawić ona według równania: {{CentrujWzór|<MATH>dK=\sum^n_{p=1}\left({{\partial K}\over{\partial x_p}}\right)_{x_{i\neq p}}dx_p\;</MATH>|2.8}} * gdzie {{Formuła|<MATH>x_p\;</MATH>}}- parametr termodynamiczny o numerze "p" opisujący nasz badany układ. === Perpetuum mobile pierwszego rodzaju === Pierwszą zasadę termodynamiki można traktować jako zasadę zachowania energii. Mówi ona, że nie da się zbudować maszyny, która tworzy z niczego jakikolwiek energię. === Pełne sformułowanie pierwszej zasady termodynamiki === Bardzo mała zmiana energii wewnętrznej zależy od zmiany ciepła, która jest określana przez równość {{LinkWzór|2.7}} zależącą od temperatury panującej w układzie podczas wymiany nieskończenie małego ciepła i od infinitezymalnej zmianu wielkości ekstensywnej zwanej entropią w tym badanym obiekcie, a także od pracy wykonanej nad ciałem (układem) wykonanej przez siły zewnętrzne {{LinkWzór|2.6}} równoważącej siły pochodzące od ciśnienia panującej w gazie podczas jego działania na tłok, a także zależy od wymiany liczby cząstek, a także zależy od zmiany energii względem różniczki czasu, zatem korzystając z tychże wymienionych wzorów, to pierwszą zasadę termodynamiki można określić przez równanie: {{CentrujWzór|<MATH> dU=\delta Q-pdV+\mu dN+\omega dt=TdS-pdV+\mu dN+\omega dt\;</MATH>|2.9|Obramuj}} Korzystając z pierwszej zasady termodynamiki {{LinkWzór|2.2}} i wzoru {{LinkWzór|2.6}} otrzymujemy wyrażenie na infinitezymalną zmianę ciepła w zależności od bardzo małej zmiany energii wewnętrznej układu i wykonanej pracy w układzie podczas zmiany jego objętości: {{CentrujWzór|<MATH>\delta Q=dU-\delta W\Rightarrow\delta Q=dU+pdV-\mu dN-\omega dt\;</MATH>|2.10|Obramuj}} === Intuicyjne wyprowadzenie "Pierwszej zasady termodynamiki" === Zakładając, że ścianka naczynia z tłokiem jest idealnie gładka (zderzenia cząstek ze ściankami naczynia są całkowicie doskonałe), wtedy przesuwając tłok o bardzo małe przesunięcie {{Formuła|<MATH>d\vec{r}\;</MATH>}} zmieniamy objętość układu o infinitezymalną wartość {{Formuła|<MATH>dV\;</MATH>}}, wtedy zmiana energii wewnętrznej gazu jest równa pracy wykonanej przez układ wedle zasady zachowania energii, czyli wedle równania {{Formuła|<MATH>\delta W=-pdV\;</MATH>}}. Gdy ścianka nie jest idealnie gładka, wtedy poszczególne cząstki badanego danego układu podczas zderzeń ze ściankami dawane im jest ze strony ścianek, im ograniczających badanego układu, z części swojej energii kinetycznej z drgań i ruchu postępowego cząsteczek w ściankach, co wyrażane jest poprzez infinitezymalną zmianę entropii w temperaturze T w jakim układ się znajduje (zakładamy przy czym, że układ znajduje się w stanie równowagi termodynamicznej), a ciepło to jest wyrażone przez {{Formuła|<MATH>\delta Q=TdS</MATH>}}, cząstki mogą dochodzić do układu, co zwiększa wtedy jego energię o {{Formuła|<MATH>\mu dN\;</MATH>}}, a także energia w układzie może się wydzielać od wiązań chemicznych lub jądrowych, a nawet mieszania się składników, co zwiększa wtedy jego energię o {{Formuła|<MATH>\omega dt\;</MATH>}}, zsumując te energie otrzymujemy zmianę energii wewnętrznej, to na podstawie tego otrzymujemy wzór {{LinkWzór|2.2}}, który jest treścią pierwszej zasady termodynamiki fenomenologicznej. === Pierwsza zasada termodynamiki jako prawo przemiany energii === Dla procesów adiabatycznych, energia wymieniana na w sposób ciepła wynosi zero, czyli wiemy korzystając przy tym ze wzoru {{LinkWzór|2.7}} na infinitezymalną zmianę ciepła, że całka temperatury całkowaną względem entropii podczas omawianej przemiany wynosi z oczywistych powodów zero: {{CentrujWzór|<MATH>0=\Delta Q=\int TdS=\overline T\int dS\Rightarrow \int dS=0\Rightarrow \sum_i\delta S_i=0</MATH>|2.11}} Na podstawie wzoru {{LinkWzór|2.11}} zmiana entropii całego układu, która nie wymienia ciepła jest zero, na podstawie z twierdzenie średnich dla całek Riemanna, również podobne twierdzenie zachodzi dla sum dla różnic entropii o numerach {{Formuła|<MATH>i\;</MATH>}}. Wykorzystując {{LinkWzór|2.10}}, która omawia pierwszą zasadę termodynamiki, jeśli podczas naszego procesu zmiana ciepła jest zero, to wtedy ze względu, że energia wewnętrzna U posiada różniczkę zupełną energii wewnętrznej, to różniczka pracy, która w ogólności nie jest różniczką zupełną, w tym szczególnym przypadku dla naszej omawianej przemiany różniczka pracy jest różniczką zupełną. {{CentrujWzór|<MATH>\Delta U=\left(\Delta W\right)_{ad}</MATH>|2.12}} W tym przypadku można sformułować zasadę: : ''Dla procesów adiabatycznych zmiana stanu układu termodynamicznego wywołana jest przez pracę sił zewnętrznych niezależnych od sposobu w jakim ta zmiana jest wykonywana, czyli mamy równanie powiedziane {{LinkWzór|2.12}}, U posiada różniczkę zupełną i jest zależna od parametrów opisujących układ, wtedy różniczka pracy {{LinkWzór|2.6}} dla procesów adiabatycznych jest różniczką zupełną, bo zachodzi:'' {{CentrujWzór|<MATH>\Delta U=U_2-U_1=\int^2_1 dU=\int^2_1\delta W</MATH>|2.13}}'' == Druga zasada termodynamiki == Podamy różne sformułowania drugiej zasady termodynamiki: '''Sformułowanie Clausiusa''': :Niemożliwe jest przekazywanie ciepła od ciała o niższej temperaturze ciału o temperaturze wyższej bez wprowadzenia innych zmian w obu ciałach i ich otoczeniu. '''Sformułowanie Kelvina''': : Nie możliwe jest pobieranie ciepła z jednego źródła i zamianę go na pracę bez prowadzenia innych zmian w układzie i otoczeniu. Ogólnie zmiana entropii jest całką, przy którym z korzystamy ze wzoru {{LinkWzór|2.7}}, która jest napisana w zależności od infinitezymalnej zmiany ciepła wymienianego między układem a otoczeniem. Jeśli poszczególne zmiany infinitezymalne parametrów stanu są nałożone na pewną krzywą stanu układu, w którym mówiąc ogólnie jest zmiana temperatury, ale nie musi tak zachodzić, to wtedy całkowitą zmianę entropii między dwoma punktami końcowymi (punktem początkowym i końcowym, między dwoma stanami, w której ta zmiana jest wykonywana) jest określona jako całka infinitezymalnych entropii określająca dany pośredni stan między badanymi stanami krańcowymi, w którym ogólnie występuje zmiana temperatury: {{CentrujWzór|<MATH>\Delta S=\int\limits^{stan 2}_{stan 1}dS=\int\limits^{stan 2}_{stan 1} {{\delta Q}\over{T}}\;</MATH>|2.14}} Drugą zasadę termodynamiki, która określa, że całkowita zmiana entropii badanego układu nigdy nie maleje i którą można zapisać w postaci warunku: {{CentrujWzór|<MATH> \Delta S\geq 0\;</MATH>|2.15}} Dla układów termodynamicznych znak równości {{LinkWzór|2.15}} dotyczy procesów odwracalnych. Całkowita entropia układu określa całkowite nieuporządkowanie układu, a jego zmiana jest tak napisana, by nie zmniejszać nieuporządkowania (bałaganu) układu, którego badamy, chociaż potocznie by się wydawało być odwrotnie, tzn. czy jest większy porządek na początku wszechświata, czy teraz, by się wydawało, że teraz, a w fizyce tak już nie jest, w fizyce jest odwrotnie niż według potocznego punktu widzenia. ===Perpetuum mobile drugiego rodzaju=== Perpetuum mobile drugiego rodzaju - całe ciepło pobrane od ciała nie da się zamienić całkowicie na pracę, czyli musi być, że: {{CentrujWzór|<MATH> \delta Q \ne dW\;</MATH>|2.16}} a gdyby istniało to urządzenie, to wtedy dałoby się zamienić całkowicie ciepło na pracę, ale według drugiej zasady termodynamiki to niemożliwe. == Trzecia zasada termodynamiki == Według trzeciej zasady termodynamiki mamy, że entropia i ciepło właściwe znikają w temperaturze T=0. Podczas przemian fizycznych, nigdy nie można dojść to temperatury T=0, a jedynie do bardzo jej bliskiego dodatniego otoczenia, ponieważ ciepło substancji maleje asymptotycznie do zera. == Wyprowadzenie "Zerowej zasady termodynamiki" == Podzielmy nasz układ na n części, najlepiej by liczba tych części była liczbą nieskończenie dużą lub prawie nieskończoną, by poszczególne podukłady były infinitezymalnie małe, na tyle małe by w takiej cząstce znajdowała się na tyle dużo cząstek by prawa termodynamiki były spełnione, chodzi tutaj o wzór na infinitezymalną pracę i o drugą zasadę termodynamiki. Wiemy jednak, że całkowita zmiana energii wewnętrznej dla n podukładów jest niezmienna z zasady zachowania energii całego układu i wynosi zero: {{CentrujWzór|<MATH>\sum^n_{i=1}dU_i=0\;</MATH>|2.17}} Wiadomo, że objętość całego układu jest niezmienna i jej zmiana w zależności od zmian objętości w poszczególnych częściach tego układu jest zero (tzn.: sumaryczna zmiana objętości całego układu jako zmiany poszczególnych jej składników jest równa zero): {{CentrujWzór|<MATH>\sum^n_{i=1}dV_i=0\;</MATH>|2.18}} Zmiana cząstek układu danej substancji i fazy jest równa zero w układzie zamkniętym: {{CentrujWzór|<MATH>\sum^n_{i=1}dN_i=0\;</MATH>|2.18a}} Rozpatrujemy układ w danym czasie statystycznym, mówiąc: {{CentrujWzór|<MATH>dt_i=dt=0\;</MATH>|2.18b}} Z pierwszej zasady termodynamiki wiadomo mamy wzór {{LinkWzór|2.2}}, a także mamy wzór na infinitezymalną wykonaną pracę poprzez infinitezymalną zmianę jej objętości {{LinkWzór|2.6}}, oraz ciśnienie w całym układzie jest niezależne od punktu, w którym układ jest badamy i jest stałe dla całego układu (bo układ jest w stanie równowagi mechanicznej, tzn. poszczególne składniki, punktu układu, są w spoczynku wedle drugiej zasady dynamiki Newtona), korzystamy tutaj ze wzoru {{LinkWzór|2.17}}, także z warunku na zmianę objętości całego układu {{LinkWzór|2.18}}, zatem zmiana energii wewnętrznej całego układu jest określona przy pomocy zmian energii na w sposób ciepła między poszczególnymi podukładami: {{CentrujWzór|<MATH>0=\sum^n_{i=1}dU_i=\sum^n_{i=1}\left(\delta Q_i+pdV_i+\mu_i dN_i+\omega_i dt_i\right)= \sum^n_{i=1}\delta Q_i+p\sum^n_{i=1}dV_i+\sum^n_{i=1}\mu_i dN_i+\sum^n_{i=1}\omega_i dt_i=\sum^n_{i=1}\delta Q_i</MATH>|2.19}} Z równania {{LinkWzór|2.19}} otrzymujemy rezultat, że całkowite ciepło wymieniane między różnymi podukładami w układzie termodynamicznym jest równe zero: {{CentrujWzór|<MATH>\sum^n_{i=1}\delta Q_i=0\;</MATH>|2.20}} Podzielmy obie strony równania {{LinkWzór|2.20}} przez stałą C o wymiarze temperatury, wtedy otrzymujemy inne równoważne równanie, bo mamy tutaj zawsze, że stała C jest nierówna zero z definicji: {{CentrujWzór|<MATH>\sum^n_{i=1}{{\delta Q_i}\over{C}}=0\;</MATH>|2.21}} Z drugiej zasady termodynamiki {{LinkWzór|2.15}} dla układów odwracalnych całkowita entropia całego układu jest sumą infinitezymalnych zmian entropii różnych podukładów i jako całość nie zmienia się: {{CentrujWzór|<MATH>0=\sum^n_{i=1}{{\delta Q_i}\over{T_i}}\;</MATH>|2.22}} Odejmijmy równanie {{LinkWzór|2.22}} od wzoru {{LinkWzór|2.21}}, stąd dostajemy: {{CentrujWzór|<MATH>\sum^n_{i=1}\left({{1}\over{C}}-{{1}\over{T_i}}\right)\delta Q_i=0\;</MATH>|2.23}} Równanie {{LinkWzór|2.23}} jest spełnione dla dowolnego ciepła przekazywanej między różnymi podukładami, wtedy: {{CentrujWzór|<MATH>{{1}\over{C}}-{{1}\over{T_i}}=0\Rightarrow C=T_i\;</MATH>|2.24}} Stała {{Formuła|<MATH>C\;</MATH>}} jest niezależna od rodzaju układów i od numeru "i", zatem dochodzimy do wniosku, że temperatura całego układu jest stała i jest taka sama, niezależna od numeru podukładu, w którym ta temperatura obowiązuje, ani od zmiany objętości poszczególnych podukładów, czyli: {{CentrujWzór|<MATH>T=C=T_1=T_2=...=T_n\;</MATH>|2.25}} Z {{LinkWzór|2.25}} z pierwszej i drugiej zasady termodynamiki w stanie równowagi termodynamicznej dla układów odwracalnych wynika zerowa zasada termodynamiki, czyli ta zasada została udowodniona na podstawie pierwszej i drugiej zasady termodynamiki (przemiany quasistatyczny) i równowagi mechanicznej poszczególnych cząstek (podukładów) w całym wielkim układzie. <noinclude>{{SkomplikowanaStronaKoniec}}</noinclude> aufta18xl4u9yiij965jvps21qv71xe 10 58549 538638 535509 2026-03-31T10:52:32Z Persino 2851 538638 sanitized-css text/css body.skin--responsive .strona_start{ font-size:1rem; line-height:1.4; } body:not(.skin--responsive) .strona_start{ font-size:16px; line-height:1.4; } .strona_prawa .spis{ display:flex; flex-direction:column; width:100%; } .strona_prawa .spis > div, .strona_prawa .spis > div > div{ height:auto; max-height:100%; } .strona_prawa .spis > div, .strona_prawa .spis > div > div{ height:auto; max-height:100%; width:auto; display:flex !important; flex-direction:column; box-sizing:border-box; } .strona_prawa .spis .style_strony_bocznego_menu, .strona_prawa .spis .style_strony_TOC{ overflow:auto; } @media all and (max-width:745px){ .strona_prawa .spis > div, .strona_prawa .spis > div > div{ width:100% !important; } } .strona_prawa .mw-sticky-y.spis:not(:hover){ transform: scale(0.3,0.3) translate(-116.5%,-116.5%); /**/ transition: transform 500ms ease-out, linear; transition-property: transform; transition-duration: 500ms; transition-timing-function: ease-out, linear; transition-delay:4s; } .strona_prawa .mw-sticky-y.spis:hover{ max-width:43.75rem !important; transform: scale(1,1) translate(0,0); transition: transform 500ms ease-out, linear; transition-property: transform; transition-duration: 500ms; transition-timing-function: ease-out, linear; transition-delay: 0s; } .strona_prawa .pierwsza_strona.mw-overflow-y.mw-scrollbar-overflow-y{ padding-right:0.3125rem; } .strona_prawa .pierwsza_strona .wikitable{ margin-top:0.3125rem; margin-bottom:0.3125rem; } .strona_prawa .pierwsza_strona hr.pierwsza_strona_spis_treści-hr{ height: 1px; background-color: var(--border-color-base,#a2a9b1); border: 0; margin: 0.2em 0; } .strona_start.tło_strona_start, .strona_start .tło_strona_nadrzędna, .strona_start .tło_główna_strona, .strona_start .tło_strona_środkowa, .strona_start .tło_strona, .strona_start .tło_ciało_kontener, .strona_start .tło_ciało_strona{ background-color:white; background-image: none; } .strona_prawa .nawigacja_boksy > .mw-optimal-x > div{ margin-top:0 !important; margin-bottom:0.3125rem !important; margin-left:0.3125rem !important; margin-right:0 !important; } .strona_lewa .nawigacja_boksy > .mw-optimal-x > div{ margin-top:0 !important; margin-bottom:0.3125rem !important; margin-right:0.3125rem !important; margin-left:0 !important; } .strona_prawa .mw-optimal-x:hover, .strona_lewa .mw-optimal-x:hover{ transform: scale(1,1) translate(0,0); max-width:none !important; transition: transform 500ms ease-out, linear; transition-property: transform; transition-duration: 500ms; transition-timing-function: ease-out, linear; transition-delay: 0s; } .strona_prawa .mw-optimal-x:not(:hover){ transform: scale(0.3,0.3) translate(116.5%,-116.5%); transition: transform 500ms ease-out, linear; transition-property: transform; transition-duration: 500ms; transition-timing-function: ease-out, linear; transition-delay:4s; } .strona_lewa .mw-optimal-x:not(:hover){ transform: scale(0.3,0.3) translate(-116.5%,-116.5%); transition: transform 500ms ease-out, linear; transition-property: transform; transition-duration: 500ms; transition-timing-function: ease-out, linear; transition-delay:4s; } html.client-nojs .strona_prawa, html.client-nojs .strona_lewa{ overflow-x:auto !important; overflow-y:hidden !important; } html.client-nojs .strona_prawa .mw-sticky-y.spis{ visibility:visible !important; position:relative !important; } html.client-nojs .strona_prawa .mw-sticky-y.spis:hover{ width: 100% !important; max-width:calc( 100% - 0.3125rem ) !important; height:auto !important; } html.client-nojs .strona_prawa .mw-sticky-y.spis:not(:hover){ width:100% !important; max-width:calc( 100% - 0.3125rem ) !important; height:auto !important; } html.client-nojs .strona_prawa .mw-sticky-y.spis:hover{ transform:none; transition:none; } html.client-nojs .strona_prawa .mw-sticky-y.spis:not(:hover){ transform:none; transition:none; } html.client-nojs .strona_prawa .mw-sticky-y > .style_strony_TOC, html.client-nojs .strona_prawa .mw-sticky-y > .style_strony_bocznego_menu{ overflow:auto; padding-bottom:0.3125rem; } .strona_prawa .mw-sticky-y > .style_strony_TOC > .strona_spisu_treści, .strona_prawa .mw-sticky-y > .style_strony_bocznego_menu > div{ flex:0 0 auto; } html.client-nojs .strona_prawa .nawigacja_boksy, html.client-nojs .strona_lewa .nawigacja_boksy{ margin-top:0.3125rem !important; visibility:visible !important; } html.client-nojs .strona_prawa .mw-optimal-x:not(:hover), html.client-nojs .strona_lewa .mw-optimal-x:not(:hover){ transform:none; transition:none; } html.client-nojs .strona_prawa .mw-optimal-x:hover, html.client-nojs .strona_lewa .mw-optimal-x:hover{ transform:none; transition:none; } html.client-nojs .strona_prawa .mw-optimal-x, html.client-nojs .strona_lewa .mw-optimal-x{ overflow:auto !important; visibility:visible !important; position:relative !important; z-index:1 !important; direction: rtl; width: auto !important; } html.client-nojs .strona_prawa .mw-optimal-x:not(:hover), html.client-nojs .strona_lewa .mw-optimal-x:not(:hover){ width: auto !important; max-width: calc( 100% - 0.3125rem ) !important; height: auto !important; } html.client-nojs .strona_prawa .mw-optimal-x:hover, html.client-nojs .strona_lewa .mw-optimal-x:hover{ z-index:3 !important; width:100% !important; max-width:calc( 100% - 0.3125rem ) !important; } body.skin-minerva .strona_start{ margin-top:0.25rem !important; } .strona_prawa .mw-optimal-x.mw-optimal-js.mw-scrollbar-overflow-x:not(:hover), .strona_lewa .mw-optimal-x.mw-optimal-js.mw-scrollbar-overflow-x:not(:hover){ overflow:auto; } .strona_prawa .mw-optimal-x, .strona_lewa .mw-optimal-x{ display:flex; flex-direction:column; } .strona_lewa .mw-optimal-x > div, .strona_prawa .mw-optimal-x > div{ flex:0 0 auto; } .strona_start .strona .ciało_zawartości > .menu > .menu_boks:hover{ background-color:blue !important; color:white !important; } .strona_start .strona .ciało_zawartości > .menu > .menu_boks:active{ background-color:grey !important; color:white !important; } .strona_start .strona .ciało_zawartości > .menu > .menu_boks:not(:hover):not(:active){ background-color:white !important; color:black !important; } /**/ .strona > div > .ciało_kontener > .ciało_strona > :last-child.noprint > p:last-child{ margin-bottom:0 !important; padding-bottom:0 !important; } .strona > div:not(:only-child) > .ciało_kontener > *:nth-child(2) > .noprint > p:last-child, .strona > div > .ciało_kontener:not(:only-child) > *:nth-child(2) > .noprint > p:last-child{ margin-bottom:0 !important; padding-bottom:0 !important; } .strona > div > .ciało_kontener > :nth-child(2):not(:empty) + .ciało_strona, .strona > div:not(:only-child) > .ciało_kontener > .ciało_strona, .strona > div > .ciało_kontener:not(:only-child) > .ciało_strona{ padding-bottom:0 !important; } .strona > div > .ciało_kontener > *:nth-child(1) > :not(style):not(link){ margin-top:0.625rem; } .strona > div > .ciało_kontener > *:nth-child(1) > :not(style):not(link) + :not(style):not(link){ margin-top:initial; } .strona > div > .ciało_kontener > *:nth-child(2) > :not(.nawigacja):not(.nawigacja-dół):last-child{ margin-bottom:0.625rem; } .strona > *:not(:first-child), .strona > div > *:not(:first-child){ margin-left:0.5rem; margin-right:0.5rem; } .strona > *:nth-child(2), .strona > div > *:nth-child(2){ margin-top:0.25rem; margin-bottom:0.125rem; } .strona > *:not(:nth-child(2)):not(:first-child), .strona > div > *:not(:nth-child(2)):not(:first-child){ margin-top:0.125rem; margin-bottom:0.125rem; } .strona > *:last-child:not(:first-child), .strona > div > *:last-child:not(:first-child){ margin-top:0.125rem; margin-bottom:0.5rem; } /**/ .strona h1, .strona h2,.strona h3,.strona h4,.strona h5,.strona h6{ text-align:left; } .strona > div > .ciało_kontener > .ciało_strona > p:first-child{ margin-top:0; } .strona > div > .ciało_kontener > .ciało_strona > p:not(.br-clear):last-child{ margin-bottom:0; } .strona > div > .ciało_kontener > .ciało_strona > div.nawigacja.nawigacja-dół{ margin-top:0.5rem !important; } .strona > div > .ciało_kontener > .ciało_strona > :not(style):not(link):not(p).floatleft + p, .strona > div > .ciało_kontener > .ciało_strona > :not(style):not(link):not(p).floatright + p, .strona > div > .ciało_kontener > .ciało_strona > :not(style):not(link):not(p).tleft + p, .strona > div > .ciało_kontener > .ciało_strona > :not(style):not(link):not(p).tright + p, .strona > div > .ciało_kontener > .ciało_strona > :not(style):not(link):not(p).float-left-or-right + p, .strona > div > .ciało_kontener > .ciało_strona > figure.mw-halign-left + p, .strona > div > .ciało_kontener > .ciało_strona > figure.mw-halign-right + p{ margin-top:0; } @media print{ .noprint{ display:none; } .print{ display:block; } } .gallerytext, .plainlinks{ text-align:left; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona p + ul, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona p + ol, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona p + ul, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona p + ol{ margin-top:-0.2rem; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona p, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona p{ font-size: inherit; line-height: 1.25em; } .strona > div > .ciało_kontener.mw-scrollbar-overflow-x{ padding-bottom:0.3125rem; } .strona > div > .ciało_kontener.mw-scrollbar-overflow-y{ padding-right:0.3125rem; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona figure.mw-halign-left[typeof="mw:File"] + ul, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona figure.mw-halign-left[typeof="mw:File"] + ul, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona figure.mw-halign-left[typeof="mw:File"] + ol, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona figure.mw-halign-left[typeof="mw:File"] + ol, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .szablon_plik + ul, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .szablon_plik + ul, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .szablon_plik + ol, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .szablon_plik + ol{ list-style-position:inside; margin-left:0; margin-inline-start:0; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight{ display:flex; flex-direction:column; max-width:100%; overflow-x:auto; overflow-y:hidden; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight > pre, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight > pre{ display:block; width:auto !important; min-width:100%; text-align:left; box-sizing:border-box; white-space:pre-wrap; flex-shrink:0; } .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight > pre, .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona div.mw-highlight > pre, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona code{ word-wrap:break-word !important; word-break:break-all !important; } @media all{ :not(style):not(link) ~ .strona_start{ margin-top:0.3125rem !important; } .strona_start p{ margin: 0.4em 0 0.5em 0; } } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table{ margin-top:0 !important; margin-bottom:0.3125rem !important; } .strona_start.niekolumnowy > div.mójNagłówek > div:last-child, .strona_start.kolumnowy > .strona_nadrzędna > div.mójNagłówek > div:last-child{ margin-bottom:0 !important; } @media all and (max-width:745px), all and (max-device-width: 745px), all and (max-device-height: 745px){ .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table{ margin-bottom:0.25rem !important; } .strona_start.kolumnowy.mobilne{ max-width:100vw !important; min-width:auto !important; width:100% !important; } .strona_start.kolumnowy.mobilne div > .ciało_kontener > *{ min-width:100% !important; max-width:100% !important; width:100% !important; } .strona_start.kolumnowy.mobilne .strona{ overflow:hidden !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div.mójNagłówek > div:last-child{ margin-bottom:0 !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div.mójNagłówek{ margin-bottom:0.25rem !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2), .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table{ max-width:none !important; width:100% !important; margin-left:0 !important; margin-right:0 !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table > tr > th:last-child, .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table > tr > td:last-child, .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table > tbody > tr > th:last-child, .strona_start.kolumnowy.mobilne > .strona_nadrzędna > div:nth-child(2) > table > tbody > tr > td:last-child{ font-size:0.80rem !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona{ flex-wrap: wrap; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > div{ position:static !important; margin-left:0 !important; margin-right:0 !important; margin-top:0 !important; margin-bottom:0 !important; transition:none !important; transform:none !important; visibility:visible !important; min-width:auto !important; max-width:100vw !important; width:100% !important; box-sizing:border-box !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > div.nawigacja_boksy > .mw-optimal-x{ transition:none !important; transform:none !important; position:static !important; margin-left:0 !important; float:none !important; clear:none !important; max-width:100% !important; width:100% !important; box-sizing:border-box; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > div.nawigacja_boksy > .mw-optimal-x > div{ width:100% !important; box-sizing:border-box; margin: 0 !important; margin-bottom:0.25rem !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > div.nawigacja_boksy > .mw-optimal-x > div > div:last-child{ font-size:0.80rem !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_lewa{ order:1 !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa{ order:2 !important; display:flex; flex-direction:column; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > .kontener_spis_treści a.zaznaczone, .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > div > .pierwsza_strona > div tr:last-child > td > div.toc_ogólnie_spis a.zaznaczone, .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > .strona_spisu_treści > .toc_wykaz a.zaznaczone{ color: #3366cc !important; font-weight: normal !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_środkowa{ order:3 !important; width:100%; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > div.nawigacja_boksy{ order:1; height:auto !important; max-height:100% !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y{ order:2; height:100% !important; max-height:100% !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > div{ width:100% !important; box-sizing:border-box !important; margin-bottom:0.25rem !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > div > .pierwsza_strona > div tr:last-child > td > div.toc_ogólnie_spis{ max-height:100% !important; overflow:visible !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y .toc_spis{ overflow:visible !important; width:100% !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona{ min-width:auto !important; max-width:100vw !important; width:100% !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_środkowa > .menu{ display:none !important; } .strona_start.kolumnowy.mobilne > .strona_nadrzędna > .główna_strona > .strona_prawa > .mw-sticky-y > .style_strony_TOC:only-child > .kontener_spis_treści{ margin-top:0 !important; margin-bottom:0 !important; } } @media all and (max-width:745px), all and (max-device-width: 745px), all and (max-device-height: 745px){ .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .mw-heading, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .mw-heading{ display:block; text-align:left; } .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > *, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > *{ display:inline; } .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .mw-editsection, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .mw-editsection{ display:inline-flex; margin-left:1em; font-size:small; margin-right:0; vertical-align:middle; } body.skin--responsive.skin-minerva .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .mw-editsection, body.skin--responsive.skin-minerva .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .mw-editsection{ margin-left:0.3em; } .strona_start.kolumnowy > .strona_nadrzędna > .główna_strona > .strona_środkowa > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .numeracja, .strona_start.niekolumnowy > .strona > div > .ciało_kontener > .ciało_strona .mw-heading > .numeracja{ margin-top: 0; margin-bottom: auto; } } @media all{ .strona_start.niekolumnowy > .mójNagłówek, .strona_start.niekolumnowy > div:first-child:not(.mójNagłówek) > .rozdział, .strona_start.kolumnowy > .strona_nadrzędna > .mójNagłówek, .strona_start.kolumnowy > .strona_nadrzędna > div:first-child:not(.mójNagłówek) > .rozdział{ margin-top:0 !important; } .strona_start.niekolumnowy > .mójNagłówek, .strona_start.niekolumnowy > div:first-child:not(.mójNagłówek) > *, .strona_start.kolumnowy > .strona_nadrzędna > .mójNagłówek, .strona_start.kolumnowy > .strona_nadrzędna > div:first-child:not(.mójNagłówek) > *{ margin-top:0 !important; margin-bottom:0.25rem !important; } } @media all and (max-width:745px), all and (max-device-width: 745px), all and (max-device-height: 745px){ figure[typeof~="mw:File"].mw-halign-left{ float:left !important; margin:4px 4px 4px 0 !important; } figure[typeof~="mw:File"].mw-halign-right{ float:right !important; margin:4px 0 4px 4px !important; } figure[typeof~="mw:File"].mw-halign-center{ margin:0 auto !important; } figure[typeof~="mw:File"]{ display:block; max-width:100%; overflow:auto; } span[typeof~="mw:File"].mw-default-size{ display:inline-block; overflow:auto; max-width:100%; } div.tright{ float:right; margin:0 0 1em 1em; } div.tleft{ float:left; margin:0 1em 1em 0; } } @media all and (max-width:745px), all and (max-device-width: 745px){ div.tright, div.tleft{ margin: 0 auto !important; float:none !important; } } @media all and (max-width:745px), all and (max-device-width: 745px), all and (max-device-height: 745px){ .strona_start.niekolumnowy.mobilne > .strona{ max-width:100vw !important; min-width:auto !important; width:100% !important; overflow:auto !important; } .strona_start.niekolumnowy.mobilne > .strona .ciało_kontener > *{ min-width:auto !important; max-width:100% !important; width:100% !important; box-sizing:border-box; } } /*{{Kategoria|Szablony - arkusze stylów/StronaStart}}*/ j49njup2g65tf27w82hl8troxnzxxw4 4 60758 538634 534987 2026-03-30T19:44:49Z Persino 2851 538634 wikitext text/x-wiki <noinclude><!-- -->{{StandardowaStronaStart | nagłówek = {{Rozdział|Pomoc Wikibooks|Mechanizm MediaWiki - Moduły}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Rozdział|Koniec}} }}</noinclude>{{Spis treści}} Strona przedstawia technologię modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a właściwie spis poszczególnych rozdziałów. Moduły wywoływa się przez, np. formę: {{m|'''Nazwa modułu'''|'''Nazwa funkcji'''}}, lub przez: {{m|'''Nazwa modułu'''|'''Nazwa funkcji'''|Parametr 1|Parametr 2|...}}, albo: {{m|'''Nazwa modułu'''|'''Nazwa funkcji'''|Parametr 1 {{=}} Wartość 1|Parametr 2 {{=}} Wartość 2|...}}, lub w postaci mieszanej: {{m|'''Nazwa modułu'''|'''Nazwa funkcji'''|...|Parametr n {{=}} Wartość n|...|Parametr m|...}}, itp.. Parametry podobnie się pisze w wikikodzie i wywołuje jak szablony, tylko z tą różnicą, że w nazwie szablonu jest na samym początku: {{Code|#invoke:}}, co po nim następuje w niej nazwa modułu bez przedrostka {{Code|{{Np|Module|link=tak}}:}}, a pierwszy parametr, który nie jest liczony, jako zmienna, tylko następna z kolei, jest nazwą funkcji w tablicy eksportu. Wtedy jest wywoływany moduł, a w niej ściśle określona funkcja z parametrami jej ramki. Parametrami funkcji też mogą być parametry szablonu rodzica, w której wywoływana jest ta ona. == Moduły podstawowe == {{Kolumny|2| {{SpisTreści|Parametry}} {{SpisTreści|Html}} {{SpisTreści|Książkowe}} {{SpisTreści|Nazwy}} {{SpisTreści|Nazwy - Tom I}} {{SpisTreści|Nazwy - Tom II}} {{SpisTreści|Nazwy - Tom III}} {{SpisTreści|Nazwy - Tom IV}} {{SpisTreści|Nazwy/Np}} {{SpisTreści|Pudełko}} {{SpisTreści|Ramka}} {{SpisTreści|Specjalne}} {{SpisTreści|StronicowyParser}} {{SpisTreści|Szeregi}} {{SpisTreści|Szablonowe}} {{SpisTreści|Techniczne}} {{SpisTreści|Wiki}} }} == Moduły standardowe == {{Kolumny|2| {{SpisTreści|Kategorie}} {{SpisTreści|Linki}} {{SpisTreści|Łatki}} {{SpisTreści|Skrót}} {{SpisTreści|Strony}} {{SpisTreści|Sprawdź}} }} == Moduły specjalistyczne == {{Kolumny|2| {{SpisTreści|Tabela}} {{SpisTreści|Sekcja referencyjna}} {{SpisTreści|Licencja}} {{SpisTreści|Przypisy}} {{SpisTreści|Dopracować}} }} {{BrClear}} <noinclude><!-- -->{{StandardowaStronaKoniec}}<!-- -->{{Kategorie | Opisy funkcji, w Lua w Scribunto, w modułach | sortuj spacją 1 = tak | Pomoc - Problemy wywołań mechanizmu MediaWiki }}<!-- --></noinclude> 1ktb6zaxrhuwgxngga8bni4bslch9hx 828 61693 538636 538176 2026-03-31T10:24:56Z Persino 2851 538636 Scribunto text/plain -- Zmienne potrzebne do funkcji: p.NazwaSortowaniaNazwyStrony(frame), która jest wykorzystywana do domyślnego formatowania stron do szablonów: "Kategoria" i "Kategorie", i ich pochodnych, które korzystają z funkcji o takich samych nazwach, co te szablony. local p={}; p.tablica_wyrazowa_alternatyw={ ["i"]=true, ["lub"]=true, ["oraz"]=true, ["bądź"]=true, ["ewentualnie"]=true, ["natomiast"]=true, }; p.tablica_wyrazowa_gdy_alternatywy={ ["szablon"]=true, }; p.tablica_wyrazowa_niealternatyw={ ["o"]=true, ["w"]=true, ["z"]=true, ["ze"]=true, ["od"]=true, ["ode"]=true, ["do"]=true, ["dla"]=true, ["na"]=true, ["pod"]=true, ["nad"]=true, ["znad"]=true, ["spod"]=true, ["stamtąd"]=true, ["podnad"]=true, ["bez"]=true, ["nie"]=true, ["tak"]=true, ["brak"]=true, ["spoza"]=true, }; p.tablica_wyrazowa_wybrane_przyimki={ ["o"]=true, ["z"]=true, ["ze"]=true, ["w"]=true, ["na"]=true, ["do"]=true, ["bez"]=true, ["od"]=true, }; p.tablica_wyrazy_niedopuszczalne={ ["infobox"]=true, ["wikibooks"]=true, ["mediawiki"]=true, }; p.tablica_analizowanie_bez={ ["Wikibooks"]=true, ["MediaWiki"]=true, ["TemplateStyles"]=true, ["Lua"]=true, ["Scribunto"]=true, ["HTML"]=true, ["XHTML"]=true, ["CSS"]=true, ["String"]=true, ["Dump"]=true, ["Wikidan"]=true, ["Opis"]=true, }; p.tablica_analizowanie_specjalne_wyrazy={ ["błędam"]=true, }; p.tablica_wyrazy_do_usuwania_przez_sortowanie={ ["używa"]=true, ["wymag"]=true, ["podział"]=true, ["taki"]=true, ["jaki"]=true, ["samy"]=true, ["któr"]=true, ["zwróc"]=true, ["przez"]=true, ["przestarz"]=true, ["postac"]=true, ["zawier"]=true, ["zawar"]=true, ["byc"]=true, ["dotycz"]=true, ["duż"]=true, ["mał"]=true, ["liczb"]=true, ["musi"]=true, ["musz"]=true, ["zgłaszan"]=true, ["przekracz"]=true, ["dopuszcz"]=true, ["duż"]=true, ["prawidł"]=true, ["samozamykaj"]=true, ["zależ"]=true, ["wyświetl"]=true, ["inn"]=true, ["tej"]=true, ["tego"]=true, ["pełn"]=true, ["dawn"]=true, --["definicj"]=true, ["główn"]=true, ["określon"]=true, ["poprawn"]=true, ["istniejąc"]=true, ["znan"]=true, ["zgodn"]=true, ["wszystk"]=true, ["sprawdzen"]=true, ["osobn"]=true, ["tworz"]=true, ["wywołan"]=true, ["wywołań"]=true, ["obsługując"]=true, ["wartość"]=true, ["pudełek"]=true, ["parametr"]=true, ["pozostał"]=true, ["użyc"]=true, ["szablonów"]=true, ["podano"]=true, ["złym"]=true, ["dobrym"]=true, ["brak"]=true, ["nazwanym"]=true, ["obiektam"]=true, ["pusty"]=true, ["puste"]=true, ["wykorzyst"]=true, ["potrzeb"]=true, ["korzystan"]=true, }; p.tablica_wyrazy_przez_sortowanie={ ["brak"]=true, ["spis"]=true, ["istniej"]=true, ["zobacz"]=true, ["grup"]=true, }; p.tablica_wyrazy_parsowania_nazwy_sortowania={ ["obiekt[^%s]*$"]=true, }; p.tablica_zmiana_liczenia_nazwy_sortowania={ ["odnośnik"]=true, }; p.tablica_dzielenia_elementowa_sortowania={ ["miast"]=true, ["gmin"]=true, ["powiat"]=true, ["województw"]=true, }; p.tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie={ ["jest"]=true, ["może"]=true, ["można"]=true, ["być"]=true, ["zbyt"]=true, ["dane"]=true, ["się"]=true, ["szablon"]=true, ["według"]=true, }; p.tablica_wydzielania_subelementowych={ ["Link"]=true, }; p.tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania={ ["artykuły"]=true, ["podręczniki"]=true, ["artykuły dla dzieci"]=true, ["podręczniki dla dzieci"]=true, ["strony brudnopisu opisu modułów"]=true, ["strony brudnopisu opisu szablonów"]=true, ["strony brudnopisu modułów"]=true, ["strony brudnopisu szablonów"]=true, ["strony opisu modułów"]=true, ["strony opisu szablonów"]=true, ["strony modułów"]=true, ["strony szablonów"]=true, ["jednostki brudnopisu projektu"]=true, ["strony brudnopisu projektu"]=true, ["strony kategorii"]=true, ["strony pomocy"]=true, ["strony projektu"]=true, ["jednostki użytkowników"]=true, ["strony użytkowników"]=true, ["strony niepodręcznikowe"]=true, }; return p; pzpevc0pamr2z1csyepkvwd7l6bdkn3 828 62837 538635 538164 2026-03-31T09:57:20Z Persino 2851 538635 Scribunto text/plain local p={}; function p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wydzielania_subelementowych=kategorie_dane_modul.tablica_wydzielania_subelementowych; local ile;local ile_zastapien=0; local nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^(%a%l%l+)(%u+.*)$",function(wyraz,dalej) if(tablica_wydzielania_subelementowych[wyraz])then ile_zastapien=ile_zastapien+1; return dalej; end; return nil; end); return nazwa_sortowania,(ile-ile_zastapien); end; local CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania=function(nazwa_sortowania) local czy_tak=mw.ustring.match(nazwa_sortowania,"^[%c%s_%p]*$") if(czy_tak)then return true;end; return false; end; local UsuwanieElementuArtykularnegoWoluminu=function(nazwa_sortowania,nawias_lewy,nawias_prawy) local ile_zmieniono=0; local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania=kategorie_dane_modul.tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania; nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%"..nawias_lewy.."[%p%s_]*([^%"..nawias_lewy.."%"..nawias_prawy.."]-)[%p%s_]*%"..nawias_prawy,function(wyrazenie) if(wyrazenie=="")then return "";end; if(tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania[wyrazenie])then ile_zmieniono=ile_zmieniono+1; return ""; end; end); return nazwa_sortowania,ile_zmieniono; end; local UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony=function(nazwa_sortowania) repeat local ile1;local ile2;local ile3;local ile4;local ile5; nazwa_sortowania,ile1=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%(([^%(%)]+)%)","%1"); nazwa_sortowania,ile2=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%[([^%(%)]+)%]","%1"); nazwa_sortowania,ile3=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%{([^%(%)]+)%}","%1"); nazwa_sortowania,ile4=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*\"([^%(%)]+)\"","%1"); nazwa_sortowania,ile5=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*„([^%(%)]+)”","%1"); local ile=ile1+ile2+ile3+ile4+ile5; until (ile==0); nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*",""); return nazwa_sortowania; end; local UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania=function(nazwa_sortowania,czy_koniec) local czy_tak=CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania); if(czy_tak)then return nazwa_sortowania,0;end; local ile; if(czy_koniec)then local ile1;local ile2; nazwa_sortowania,ile1=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]+",""); nazwa_sortowania,ile2=mw.ustring.gsub(nazwa_sortowania,"[%p%s_]+$",""); ile=ile1+ile2; else local UsuwanieNiepoprawnejInterpunkcjiNawiasowej=function(nazwa_sortowania,numer) local ile;local ile_nawias; repeat if(numer==1)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"(",")"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%(([^%(%)]+)%)","%1%2"); else ile=ile_nawias; end; elseif(numer==2)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"[","]"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%[([^%[%]]+)%]","%1%2"); else ile=ile_nawias; end; elseif(numer==3)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"{","}"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%{([^%{%}]+)%}","%1%2"); else ile=ile_nawias; end; elseif(numer==4)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"\"","\""); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)\"([^\"]+)\"","%1%2"); else ile=ile_nawias; end; elseif(numer==5)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"„","”"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)„([^„”]+)”","%1%2"); else ile=ile_nawias; end; else mw.log("Funkcja: UsuwanieNiepoprawnejInterpunkcjiNawiasowej, niewłaściwa wartość parametru: numer.") end; until (ile==0); return nazwa_sortowania,ile; end; local ile1;local ile2;local ile3;local ile4;local ile5;local ile6;local ile7; nazwa_sortowania,ile1=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,1); nazwa_sortowania,ile2=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,2); nazwa_sortowania,ile3=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,3); nazwa_sortowania,ile4=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,4); nazwa_sortowania,ile5=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,5); nazwa_sortowania,ile6=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]+",""); nazwa_sortowania,ile7=mw.ustring.gsub(nazwa_sortowania,"[%s_]+$",""); ile=ile1+ile2+ile3+ile4+ile5+ile6+ile7; end; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); return nazwa_sortowania,ile; end; local ZamienianieWyrazoweSzereguWyrazu=function(nazwa_sortowania,wzor,funkcja,czy_wielkosc) nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local ile_dopasowania=0; local nazwa,ile=mw.ustring.gsub(nazwa_sortowania,wzor,function(wyraz) wyraz=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(wyraz,true); if(not czy_wielkosc)then wyraz=mw.ustring.lower(wyraz);end; local wynik=funkcja(wyraz); if(wynik)then ile_dopasowania=ile_dopasowania+1; return nil; end; return nil; end); return nazwa,ile,ile_dopasowania; end; local ZamienianieWyrazoweSzereguWyrazuKompleksowe=function(nazwa_sortowania,wzor,tablica_kompletne_wyrazy,tablica_niekompletne_wyrazy,czy_wielkosc) local ile;local ile_dopasowan; local nazwa,ile,ile_dopasowan=ZamienianieWyrazoweSzereguWyrazu(nazwa_sortowania,wzor,function(wyraz) if(tablica_kompletne_wyrazy)then if(tablica_kompletne_wyrazy[wyraz])then return true; end; end; if(tablica_niekompletne_wyrazy)then for name,_ in pairs(tablica_niekompletne_wyrazy)do local czy_dopasowano=mw.ustring.match(wyraz,"^"..name) if(czy_dopasowano)then return true; end; end; end; return nil; end,czy_wielkosc); return nazwa,ile,ile_dopasowan; end; local UsuwaneElemementyNazwySortowania=function(nazwa_sortowania,tablica_kompletne_wyrazy,tablica_niekompletne_wyrazy,czy_nie,czy_od_poczatku) nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local ile_niezastapil=0; local nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,((czy_od_poczatku and "^" or "").."%s*(%S+)"),function(wyraz) wyraz=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(wyraz,true); if(mw.ustring.match(wyraz,"^%u+$"))then ile_niezastapil=ile_niezastapil+1; return nil; end; wyraz=mw.ustring.lower(wyraz); if(tablica_kompletne_wyrazy)then if(tablica_kompletne_wyrazy[wyraz])then return ""; end; end; if(tablica_niekompletne_wyrazy)then for p_wzor_wyrazy,_ in pairs(tablica_niekompletne_wyrazy)do local p_wyraz=mw.ustring.match(wyraz,"^"..p_wzor_wyrazy) or (czy_nie and mw.ustring.match(wyraz,"^nie"..p_wzor_wyrazy) or nil); if(p_wyraz)then return ""; end; end; end; ile_niezastapil=ile_niezastapil+1; return nil; end); ile=ile-ile_niezastapil; return nazwa_sortowania,ile; end; local CzyPierwszyWyrazPrzezSortowanie=function(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_przez_sortowanie=kategorie_dane_modul.tablica_wyrazy_przez_sortowanie; for name,value in pairs(tablica_wyrazy_przez_sortowanie) do local czy_dopasowano=mw.ustring.match(nazwa_sortowania,"^"..name) or mw.ustring.match(nazwa_sortowania,"^"..mw.getContentLanguage():ucfirst(name)) or mw.ustring.match(nazwa_sortowania,"^".."nie"..name) or mw.ustring.match(nazwa_sortowania,"^"..mw.getContentLanguage():ucfirst("nie"..name)); if(czy_dopasowano)then return true; end; end; return false; end; local UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania=function(nazwa_sortowania) if(CzyPierwszyWyrazPrzezSortowanie(nazwa_sortowania))then return nazwa_sortowania,1;end; local nazwa_sortowania_stare=nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local czy_pusta_nazwa_sortowania=CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania); if(czy_pusta_nazwa_sortowania)then return nazwa_sortowania_stare,0; end; nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^%s*([^/%s]+%s+)",""); local ile_wyrazy_niedopuszczalne=0; local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_niedopuszczalne=kategorie_dane_modul.tablica_wyrazy_niedopuszczalne; local _,_,ile_wyrazy_niedopuszczalne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^(%S+)",nil,tablica_wyrazy_niedopuszczalne); if(ile_wyrazy_niedopuszczalne>0)then nazwa_sortowania=nazwa_sortowania_stare; end; return nazwa_sortowania,ile_wyrazy_niedopuszczalne; end; local IleJestSpacjiNazwySortowania=function(nazwa_sortowania) local _,ile=mw.ustring.gsub(nazwa_sortowania,"(%s)",function()return nil;end); return ile; end; local function CzyJestWeNazwieSortowaniaTenParserowyWyrazLubGrupaWyrazowa(nazwa_sortowania,tablica_parsowania) local czy_tak=false; for name,value in pairs(tablica_parsowania)do czy_tak=czy_tak or mw.ustring.match(nazwa_sortowania,"[%s%p]+"..name); if(czy_tak)then return czy_tak;end; end; for name,value in pairs(tablica_parsowania)do czy_tak=czy_tak or mw.ustring.match(nazwa_sortowania,"^"..name); if(czy_tak)then return czy_tak;end; end; return false; end; local TekstPoPrzyimkuNazwySortowania=function(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazowa_wybrane_przyimki=kategorie_dane_modul.tablica_wyrazowa_wybrane_przyimki; local tablica_zmiana_liczenia_nazwy_sortowania=kategorie_dane_modul.tablica_zmiana_liczenia_nazwy_sortowania; local tablica_analizowanie_specjalne_wyrazy=kategorie_dane_modul.tablica_analizowanie_specjalne_wyrazy; local tablica_wyrazy_parsowania_nazwy_sortowania=kategorie_dane_modul.tablica_wyrazy_parsowania_nazwy_sortowania; local tablica_wyrazowa_niealternatyw=kategorie_dane_modul.tablica_wyrazowa_niealternatyw; local tablica_analizowanie_bez=kategorie_dane_modul.tablica_analizowanie_bez; local tab_dane={}; local nie_usuwaj_pierwszego_z_kolei_wyrazu; local czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka; local tab_przyimki={}; for name,value in pairs(tablica_wyrazowa_wybrane_przyimki)do local poczatek,koniec,_,nazwa_sortowania_temp=mw.ustring.find(nazwa_sortowania,"%s+("..name..")%s+(%S.*)%s*$",1); if(poczatek)then if(((name=="z")or(name=="ze"))and((not tab_przyimki["z"])and(not tab_przyimki["ze"])))then local poczatek2,koniec2,_,nazwa_sortowania_temp2; poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania,",%s+(z)%s+(%S.*)%s*$",1); local poczatek3,koniec3,_,nazwa_sortowania_temp3=mw.ustring.match(nazwa_sortowania_temp,",%s+(z)%s+(%S.*)%s*$"); if(not poczatek3)then poczatek3,koniec3,_,nazwa_sortowania_temp3=mw.ustring.match(nazwa_sortowania_temp,",%s+(ze)%s+(%S.*)%s*$"); end; local poczatek4,koniec4,_,nazwa_sortowania_temp4=mw.ustring.match(nazwa_sortowania_temp,"[^,%s]%s+(z)%s+(%S.*)%s*$"); if(not poczatek4)then poczatek4,koniec4,_,nazwa_sortowania_temp4=mw.ustring.match(nazwa_sortowania_temp,"[^%s,]%s+(ze)%s+(%S.*)%s*$"); end; local CzyWiecej=function(nazwa_sortowania) local ile=0;local tak=false; local iter=mw.ustring.gmatch(nazwa_sortowania,"%S+"); for wyraz in iter do if(tak)then return;end; local wyraz2=mw.ustring.gsub(wyraz,"%,+$",""); wyraz2=mw.ustring.lower(wyraz2); if(tablica_wyrazowa_niealternatyw[wyraz2])then tak=true;break;end; if(not mw.ustring.match(wyraz,",$"))then ile=ile+1; else ile=ile+1; tak=true; break; end; end; if(not tak)then return 1;end; return ile; end; local czy_wiecej=nazwa_sortowania_temp2 and (CzyWiecej(nazwa_sortowania_temp2)>1) or false; local czy_warunek=((not poczatek3) or poczatek4)or(czy_wiecej); if(poczatek2)then czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=true and ((not poczatek4)or(poczatek3)); else poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania,",%s+(ze)%s+(%S.*)%s*$",1); czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=(poczatek2 and true or false) and czy_warunek; end; if(poczatek2)then local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania_temp2,"^%s*(%S+)",nil,tablica_analizowanie_specjalne_wyrazy,true); nie_usuwaj_pierwszego_z_kolei_wyrazu=(ile_wyrazy_specialne==0)and true or false; tab_dane[poczatek]={name,(not czy_warunek)and nazwa_sortowania_temp or nazwa_sortowania_temp2,}; else local poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania_temp,"%s+(z)%s+(%S.*)%s*$",1); if(not poczatek2)then poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania_temp,"%s+(ze)%s+(%S.*)%s*$",1); end; if(poczatek2)then nie_usuwaj_pierwszego_z_kolei_wyrazu=true;end; tab_dane[poczatek]={name,nazwa_sortowania_temp,}; end; elseif((name~="z")and(name~="ze"))then tab_dane[poczatek]={name,nazwa_sortowania_temp,}; end; tab_przyimki[name]=true; end; end; czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=false or czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka or ( ((not tab_przyimki["z"])and(tab_przyimki["ze"])) and(not CzyJestWeNazwieSortowaniaTenParserowyWyrazLubGrupaWyrazowa(nazwa_sortowania,tablica_wyrazy_parsowania_nazwy_sortowania)) ); if(not czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka)then for name,value in pairs(tablica_zmiana_liczenia_nazwy_sortowania)do if( mw.ustring.match(nazwa_sortowania,name) or mw.ustring.match(nazwa_sortowania,mw.getContentLanguage():ucfirst(name)) )then czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=true; break; end; end; end; local minimim_maksimum; local __min=czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka and math.min or math.max; local __max=czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka and math.max or math.min; for name,value in pairs(tab_dane)do if(not minimim_maksimum)then minimim_maksimum=name;end; if((value[1]=="w")or(value[1]=="we"))then minimim_maksimum=__min(minimim_maksimum,name); else minimim_maksimum=__max(minimim_maksimum,name); end; end; if(minimim_maksimum)then local nazwa_sortowania_temp=tab_dane[minimim_maksimum][2]; local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania_temp,"^%s*(%S+)",nil,tablica_analizowanie_bez,true); if(ile_wyrazy_specialne>0)then nie_usuwaj_pierwszego_z_kolei_wyrazu=true;end; return nazwa_sortowania_temp,1,nie_usuwaj_pierwszego_z_kolei_wyrazu; else return nazwa_sortowania,0,nie_usuwaj_pierwszego_z_kolei_wyrazu; end; end; local WydzielonaNazwaSortowaniaPoMinusieLubPauzie=function(nazwa_sortowania) local czy_niezmieniono=true; local nazwa_sortowania_temp=mw.ustring.match(nazwa_sortowania,"^%s*[^%s%-%–][^%-%–]*%s+[%-%–]%s+(%S.-)%s*$"); czy_niezmieniono=czy_niezmieniono and (not nazwa_sortowania_temp); nazwa_sortowania=nazwa_sortowania_temp or nazwa_sortowania; local nazwa_sortowania_temp=mw.ustring.match(nazwa_sortowania,"^%s*[^%s%:][^%:]*%s*[%:]%s*(%S.-)%s*$"); czy_niezmieniono=czy_niezmieniono and (not nazwa_sortowania_temp); nazwa_sortowania=nazwa_sortowania_temp or nazwa_sortowania; return nazwa_sortowania,(not czy_niezmieniono); end; local WyrazOdWielkiejLiteryNazwySortowania=function(nazwa_sortowania,czy_od_poczatku) local ktoras_duza_litera=mw.ustring.match(nazwa_sortowania,((czy_od_poczatku and "^%s*" or "%s+").."%p*%u")); return ktoras_duza_litera and true or false; end; local function UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_do_usuwania_przez_sortowanie=kategorie_dane_modul.tablica_wyrazy_do_usuwania_przez_sortowanie; local tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie=kategorie_dane_modul.tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie; local tablica_dzielenia_elementowa_sortowania=kategorie_dane_modul.tablica_dzielenia_elementowa_sortowania; local tablica_wyrazowa_niealternatyw=kategorie_dane_modul.tablica_wyrazowa_niealternatyw; repeat local ile=0;local ile1=0;local ile2=0;local ile3=0; nazwa_sortowania,ile1=UsuwaneElemementyNazwySortowania(nazwa_sortowania,tablica_wyrazowa_niealternatyw,nil,false,true); nazwa_sortowania,ile2=UsuwaneElemementyNazwySortowania(nazwa_sortowania,tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie,tablica_wyrazy_do_usuwania_przez_sortowanie,true,true); if(not ktoras_duza_litera)then nazwa_sortowania,ile3=UsuwaneElemementyNazwySortowania(nazwa_sortowania,nil,tablica_dzielenia_elementowa_sortowania,false,true); end; ile=ile1+ile2+ile3; until (ile==0); return nazwa_sortowania; end; function p.NazwaSortowaniaNazwyStrony(frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local nazwa_sortowania=args[1]; local techniczne_modul=require("Module:Techniczne"); nazwa_sortowania=techniczne_modul.UsuwanieZnakoweKontrolneNiewidzialne(nazwa_sortowania); if(not mw.ustring.match(nazwa_sortowania,"/"))then local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania=kategorie_dane_modul.tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania; local _,_,ile_jest_na_poczatku=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^[%s_]*(.-)[%s_]*$",nil,tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania); if(ile_jest_na_poczatku>0)then nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; if(CzyPierwszyWyrazPrzezSortowanie(nazwa_sortowania))then return nazwa_sortowania,true;end; local czy_zmieniono; local stara_nazwa_sortowania=nazwa_sortowania; local nazwa_sortowania_po_minusie_lub_pausie=nazwa_sortowania; nazwa_sortowania,czy_zmieniono=WydzielonaNazwaSortowaniaPoMinusieLubPauzie(nazwa_sortowania); if(czy_zmieniono)then if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; else local _,_,ile_jest_na_poczatku=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^[%s_]*(.-)[%s_]*$",nil,tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania); if(ile_jest_na_poczatku>0)then nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; end; end; local ktoras_duza_litera=WyrazOdWielkiejLiteryNazwySortowania(nazwa_sortowania); local tablica_analizowanie_bez=kategorie_dane_modul.tablica_analizowanie_bez; local tablica_analizowanie_specjalne_wyrazy=kategorie_dane_modul.tablica_analizowanie_specjalne_wyrazy; local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"%s+(%S+)",nil,tablica_analizowanie_bez,true); local _,_,ile_wyrazy_specialne_wyrazy=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"%s+(%S+)",nil,tablica_analizowanie_specjalne_wyrazy,true); local nazwa_sortowania_przed_przyimkiem=(czy_zmieniono) and nazwa_sortowania_po_minusie_lub_pausie or nazwa_sortowania; local ile_przyimki;local nie_usuwaj_pierwszego_z_kolei_wyrazu; if((not ktoras_duza_litera)or(ile_wyrazy_specialne>0)or(ile_wyrazy_specialne_wyrazy>0))then local stara_nazwa_sortowania=nazwa_sortowania; nazwa_sortowania,ile_przyimki,nie_usuwaj_pierwszego_z_kolei_wyrazu=TekstPoPrzyimkuNazwySortowania(nazwa_sortowania); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; ile_przyimki=nil; nie_usuwaj_pierwszego_z_kolei_wyrazu=nil; end; end; if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; local nazwa_sortowania_temp=UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania_temp))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; ile_przyimki=nil; nie_usuwaj_pierwszego_z_kolei_wyrazu=nil; end; mw.log(nazwa_sortowania,"TYTAn123") ile=IleJestSpacjiNazwySortowania(nazwa_sortowania); if(ile>0)then local stara_nazwa_sortowania=nazwa_sortowania; if(not ktoras_duza_litera)then local tablica_wyrazowa_alternatyw=kategorie_dane_modul.tablica_wyrazowa_alternatyw; local _,_,ile_znalezione=ZamienianieWyrazoweSzereguWyrazuKompleksowe(stara_nazwa_sortowania,"%s+(%S+)",tablica_wyrazowa_alternatyw,nil); if(ile_znalezione>0)then local tablica_wyrazowa_gdy_alternatywy=kategorie_dane_modul.tablica_wyrazowa_gdy_alternatywy; local _,_,ile_specjalne_gdy_alternatywy=ZamienianieWyrazoweSzereguWyrazuKompleksowe(stara_nazwa_sortowania,"^%s*(%S+)",nil,tablica_wyrazowa_gdy_alternatywy); if(ile_specjalne_gdy_alternatywy==0)then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; end; end; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; end; nazwa_sortowania=UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; nazwa_sortowania=UsuwanieNazwaSortowanie(nazwa_sortowania); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; end; end; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; local stara_nazwa_sortowania=nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); return nazwa_sortowania,false; end; return p; r8n7mwg8yoshpupk1m2tltccls0q8yn 538637 538635 2026-03-31T10:33:34Z Persino 2851 538637 Scribunto text/plain local p={}; function p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wydzielania_subelementowych=kategorie_dane_modul.tablica_wydzielania_subelementowych; local ile;local ile_zastapien=0; local nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^(%a%l%l+)(%u+.*)$",function(wyraz,dalej) if(tablica_wydzielania_subelementowych[wyraz])then ile_zastapien=ile_zastapien+1; return dalej; end; return nil; end); return nazwa_sortowania,(ile-ile_zastapien); end; local CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania=function(nazwa_sortowania) local czy_tak=mw.ustring.match(nazwa_sortowania,"^[%c%s_%p]*$") if(czy_tak)then return true;end; return false; end; local UsuwanieElementuArtykularnegoWoluminu=function(nazwa_sortowania,nawias_lewy,nawias_prawy) local ile_zmieniono=0; local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania=kategorie_dane_modul.tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania; nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%"..nawias_lewy.."[%p%s_]*([^%"..nawias_lewy.."%"..nawias_prawy.."]-)[%p%s_]*%"..nawias_prawy,function(wyrazenie) if(wyrazenie=="")then return "";end; if(tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania[wyrazenie])then ile_zmieniono=ile_zmieniono+1; return ""; end; end); return nazwa_sortowania,ile_zmieniono; end; local UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony=function(nazwa_sortowania) repeat local ile1;local ile2;local ile3;local ile4;local ile5; nazwa_sortowania,ile1=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%(([^%(%)]+)%)","%1"); nazwa_sortowania,ile2=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%[([^%(%)]+)%]","%1"); nazwa_sortowania,ile3=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*%{([^%(%)]+)%}","%1"); nazwa_sortowania,ile4=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*\"([^%(%)]+)\"","%1"); nazwa_sortowania,ile5=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*„([^%(%)]+)”","%1"); local ile=ile1+ile2+ile3+ile4+ile5; until (ile==0); nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]*",""); return nazwa_sortowania; end; local UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania=function(nazwa_sortowania,czy_koniec) local czy_tak=CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania); if(czy_tak)then return nazwa_sortowania,0;end; local ile; if(czy_koniec)then local ile1;local ile2; nazwa_sortowania,ile1=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]+",""); nazwa_sortowania,ile2=mw.ustring.gsub(nazwa_sortowania,"[%p%s_]+$",""); ile=ile1+ile2; else local UsuwanieNiepoprawnejInterpunkcjiNawiasowej=function(nazwa_sortowania,numer) local ile;local ile_nawias; repeat if(numer==1)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"(",")"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%(([^%(%)]+)%)","%1%2"); else ile=ile_nawias; end; elseif(numer==2)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"[","]"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%[([^%[%]]+)%]","%1%2"); else ile=ile_nawias; end; elseif(numer==3)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"{","}"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)%{([^%{%}]+)%}","%1%2"); else ile=ile_nawias; end; elseif(numer==4)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"\"","\""); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)\"([^\"]+)\"","%1%2"); else ile=ile_nawias; end; elseif(numer==5)then nazwa_sortowania,ile_nawias=UsuwanieElementuArtykularnegoWoluminu(nazwa_sortowania,"„","”"); if(ile_nawias==0)then nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,"^([%p%s_]*)„([^„”]+)”","%1%2"); else ile=ile_nawias; end; else mw.log("Funkcja: UsuwanieNiepoprawnejInterpunkcjiNawiasowej, niewłaściwa wartość parametru: numer.") end; until (ile==0); return nazwa_sortowania,ile; end; local ile1;local ile2;local ile3;local ile4;local ile5;local ile6;local ile7; nazwa_sortowania,ile1=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,1); nazwa_sortowania,ile2=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,2); nazwa_sortowania,ile3=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,3); nazwa_sortowania,ile4=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,4); nazwa_sortowania,ile5=UsuwanieNiepoprawnejInterpunkcjiNawiasowej(nazwa_sortowania,5); nazwa_sortowania,ile6=mw.ustring.gsub(nazwa_sortowania,"^[%p%s_]+",""); nazwa_sortowania,ile7=mw.ustring.gsub(nazwa_sortowania,"[%s_]+$",""); ile=ile1+ile2+ile3+ile4+ile5+ile6+ile7; end; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); return nazwa_sortowania,ile; end; local ZamienianieWyrazoweSzereguWyrazu=function(nazwa_sortowania,wzor,funkcja,czy_wielkosc) nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local ile_dopasowania=0; local nazwa,ile=mw.ustring.gsub(nazwa_sortowania,wzor,function(wyraz) wyraz=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(wyraz,true); if(not czy_wielkosc)then wyraz=mw.ustring.lower(wyraz);end; local wynik=funkcja(wyraz); if(wynik)then ile_dopasowania=ile_dopasowania+1; return nil; end; return nil; end); return nazwa,ile,ile_dopasowania; end; local ZamienianieWyrazoweSzereguWyrazuKompleksowe=function(nazwa_sortowania,wzor,tablica_kompletne_wyrazy,tablica_niekompletne_wyrazy,czy_wielkosc) local ile;local ile_dopasowan; local nazwa,ile,ile_dopasowan=ZamienianieWyrazoweSzereguWyrazu(nazwa_sortowania,wzor,function(wyraz) if(tablica_kompletne_wyrazy)then if(tablica_kompletne_wyrazy[wyraz])then return true; end; end; if(tablica_niekompletne_wyrazy)then for name,_ in pairs(tablica_niekompletne_wyrazy)do local czy_dopasowano=mw.ustring.match(wyraz,"^"..name) if(czy_dopasowano)then return true; end; end; end; return nil; end,czy_wielkosc); return nazwa,ile,ile_dopasowan; end; local UsuwaneElemementyNazwySortowania=function(nazwa_sortowania,tablica_kompletne_wyrazy,tablica_niekompletne_wyrazy,czy_nie,czy_od_poczatku) nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local ile_niezastapil=0; local nazwa_sortowania,ile=mw.ustring.gsub(nazwa_sortowania,((czy_od_poczatku and "^" or "").."%s*(%S+)"),function(wyraz) wyraz=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(wyraz,true); if(mw.ustring.match(wyraz,"^%u+$"))then ile_niezastapil=ile_niezastapil+1; return nil; end; wyraz=mw.ustring.lower(wyraz); if(tablica_kompletne_wyrazy)then if(tablica_kompletne_wyrazy[wyraz])then return ""; end; end; if(tablica_niekompletne_wyrazy)then for p_wzor_wyrazy,_ in pairs(tablica_niekompletne_wyrazy)do local p_wyraz=mw.ustring.match(wyraz,"^"..p_wzor_wyrazy) or (czy_nie and mw.ustring.match(wyraz,"^nie"..p_wzor_wyrazy) or nil); if(p_wyraz)then return ""; end; end; end; ile_niezastapil=ile_niezastapil+1; return nil; end); ile=ile-ile_niezastapil; return nazwa_sortowania,ile; end; local CzyPierwszyWyrazPrzezSortowanie=function(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_przez_sortowanie=kategorie_dane_modul.tablica_wyrazy_przez_sortowanie; for name,value in pairs(tablica_wyrazy_przez_sortowanie) do local czy_dopasowano=mw.ustring.match(nazwa_sortowania,"^"..name) or mw.ustring.match(nazwa_sortowania,"^"..mw.getContentLanguage():ucfirst(name)) or mw.ustring.match(nazwa_sortowania,"^".."nie"..name) or mw.ustring.match(nazwa_sortowania,"^"..mw.getContentLanguage():ucfirst("nie"..name)); if(czy_dopasowano)then return true; end; end; return false; end; local UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania=function(nazwa_sortowania) if(CzyPierwszyWyrazPrzezSortowanie(nazwa_sortowania))then return nazwa_sortowania,1;end; local nazwa_sortowania_stare=nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania); local czy_pusta_nazwa_sortowania=CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania); if(czy_pusta_nazwa_sortowania)then return nazwa_sortowania_stare,0; end; nazwa_sortowania=mw.ustring.gsub(nazwa_sortowania,"^%s*([^/%s]+%s+)",""); local ile_wyrazy_niedopuszczalne=0; local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_niedopuszczalne=kategorie_dane_modul.tablica_wyrazy_niedopuszczalne; local _,_,ile_wyrazy_niedopuszczalne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^(%S+)",nil,tablica_wyrazy_niedopuszczalne); if(ile_wyrazy_niedopuszczalne>0)then nazwa_sortowania=nazwa_sortowania_stare; end; return nazwa_sortowania,ile_wyrazy_niedopuszczalne; end; local IleJestSpacjiNazwySortowania=function(nazwa_sortowania) local _,ile=mw.ustring.gsub(nazwa_sortowania,"(%s)",function()return nil;end); return ile; end; local function CzyJestWeNazwieSortowaniaTenParserowyWyrazLubGrupaWyrazowa(nazwa_sortowania,tablica_parsowania) local czy_tak=false; for name,value in pairs(tablica_parsowania)do czy_tak=czy_tak or mw.ustring.match(nazwa_sortowania,"[%s%p]+"..name); if(czy_tak)then return czy_tak;end; end; for name,value in pairs(tablica_parsowania)do czy_tak=czy_tak or mw.ustring.match(nazwa_sortowania,"^"..name); if(czy_tak)then return czy_tak;end; end; return false; end; local TekstPoPrzyimkuNazwySortowania=function(nazwa_sortowania) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazowa_wybrane_przyimki=kategorie_dane_modul.tablica_wyrazowa_wybrane_przyimki; local tablica_zmiana_liczenia_nazwy_sortowania=kategorie_dane_modul.tablica_zmiana_liczenia_nazwy_sortowania; local tablica_analizowanie_specjalne_wyrazy=kategorie_dane_modul.tablica_analizowanie_specjalne_wyrazy; local tablica_wyrazy_parsowania_nazwy_sortowania=kategorie_dane_modul.tablica_wyrazy_parsowania_nazwy_sortowania; local tablica_wyrazowa_niealternatyw=kategorie_dane_modul.tablica_wyrazowa_niealternatyw; local tablica_analizowanie_bez=kategorie_dane_modul.tablica_analizowanie_bez; local tab_dane={}; local nie_usuwaj_pierwszego_z_kolei_wyrazu; local czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka; local tab_przyimki={}; for name,value in pairs(tablica_wyrazowa_wybrane_przyimki)do local poczatek,koniec,_,nazwa_sortowania_temp=mw.ustring.find(nazwa_sortowania,"%s+("..name..")%s+(%S.*)%s*$",1); if(poczatek)then if(((name=="z")or(name=="ze"))and((not tab_przyimki["z"])and(not tab_przyimki["ze"])))then local poczatek2,koniec2,_,nazwa_sortowania_temp2; poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania,",%s+(z)%s+(%S.*)%s*$",1); local poczatek3,koniec3,_,nazwa_sortowania_temp3=mw.ustring.match(nazwa_sortowania_temp,",%s+(z)%s+(%S.*)%s*$"); if(not poczatek3)then poczatek3,koniec3,_,nazwa_sortowania_temp3=mw.ustring.match(nazwa_sortowania_temp,",%s+(ze)%s+(%S.*)%s*$"); end; local poczatek4,koniec4,_,nazwa_sortowania_temp4=mw.ustring.match(nazwa_sortowania_temp,"[^,%s]%s+(z)%s+(%S.*)%s*$"); if(not poczatek4)then poczatek4,koniec4,_,nazwa_sortowania_temp4=mw.ustring.match(nazwa_sortowania_temp,"[^%s,]%s+(ze)%s+(%S.*)%s*$"); end; local CzyWiecej=function(nazwa_sortowania) local ile=0;local tak=false; local iter=mw.ustring.gmatch(nazwa_sortowania,"%S+"); for wyraz in iter do if(tak)then return;end; local wyraz2=mw.ustring.gsub(wyraz,"%,+$",""); wyraz2=mw.ustring.lower(wyraz2); if(tablica_wyrazowa_niealternatyw[wyraz2])then tak=true;break;end; if(not mw.ustring.match(wyraz,",$"))then ile=ile+1; else ile=ile+1; tak=true; break; end; end; if(not tak)then return 1;end; return ile; end; local czy_wiecej=nazwa_sortowania_temp2 and (CzyWiecej(nazwa_sortowania_temp2)>1) or false; local czy_warunek=((not poczatek3) or poczatek4)or(czy_wiecej); if(poczatek2)then czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=true and ((not poczatek4)or(poczatek3)); else poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania,",%s+(ze)%s+(%S.*)%s*$",1); czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=(poczatek2 and true or false) and czy_warunek; end; if(poczatek2)then local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania_temp2,"^%s*(%S+)",nil,tablica_analizowanie_specjalne_wyrazy,true); nie_usuwaj_pierwszego_z_kolei_wyrazu=(ile_wyrazy_specialne==0)and true or false; tab_dane[poczatek]={name,(not czy_warunek)and nazwa_sortowania_temp or nazwa_sortowania_temp2,}; else local poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania_temp,"%s+(z)%s+(%S.*)%s*$",1); if(not poczatek2)then poczatek2,koniec2,_,nazwa_sortowania_temp2=mw.ustring.find(nazwa_sortowania_temp,"%s+(ze)%s+(%S.*)%s*$",1); end; if(poczatek2)then nie_usuwaj_pierwszego_z_kolei_wyrazu=true;end; tab_dane[poczatek]={name,nazwa_sortowania_temp,}; end; elseif((name~="z")and(name~="ze"))then tab_dane[poczatek]={name,nazwa_sortowania_temp,}; end; tab_przyimki[name]=true; end; end; czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=false or czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka or ( ((not tab_przyimki["z"])and(tab_przyimki["ze"])) and(not CzyJestWeNazwieSortowaniaTenParserowyWyrazLubGrupaWyrazowa(nazwa_sortowania,tablica_wyrazy_parsowania_nazwy_sortowania)) ); if(not czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka)then for name,value in pairs(tablica_zmiana_liczenia_nazwy_sortowania)do if( mw.ustring.match(nazwa_sortowania,name) or mw.ustring.match(nazwa_sortowania,mw.getContentLanguage():ucfirst(name)) )then czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka=true; break; end; end; end; local minimim_maksimum; local __min=czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka and math.min or math.max; local __max=czy_ma_liczyc_wartosc_maksymalna_pozycji_przyimka and math.max or math.min; for name,value in pairs(tab_dane)do if(not minimim_maksimum)then minimim_maksimum=name;end; if((value[1]=="w")or(value[1]=="we"))then minimim_maksimum=__min(minimim_maksimum,name); else minimim_maksimum=__max(minimim_maksimum,name); end; end; if(minimim_maksimum)then local nazwa_sortowania_temp=tab_dane[minimim_maksimum][2]; nazwa_sortowania_temp=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania_temp); local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania_temp,"^%s*(%S+)",nil,tablica_analizowanie_bez,true); if(ile_wyrazy_specialne>0)then nie_usuwaj_pierwszego_z_kolei_wyrazu=true;end; return nazwa_sortowania_temp,1,nie_usuwaj_pierwszego_z_kolei_wyrazu; else return nazwa_sortowania,0,nie_usuwaj_pierwszego_z_kolei_wyrazu; end; end; local WydzielonaNazwaSortowaniaPoMinusieLubPauzie=function(nazwa_sortowania) local czy_niezmieniono=true; local nazwa_sortowania_temp=mw.ustring.match(nazwa_sortowania,"^%s*[^%s%-%–][^%-%–]*%s+[%-%–]%s+(%S.-)%s*$"); czy_niezmieniono=czy_niezmieniono and (not nazwa_sortowania_temp); nazwa_sortowania=nazwa_sortowania_temp or nazwa_sortowania; local nazwa_sortowania_temp=mw.ustring.match(nazwa_sortowania,"^%s*[^%s%:][^%:]*%s*[%:]%s*(%S.-)%s*$"); czy_niezmieniono=czy_niezmieniono and (not nazwa_sortowania_temp); nazwa_sortowania=nazwa_sortowania_temp or nazwa_sortowania; return nazwa_sortowania,(not czy_niezmieniono); end; local WyrazOdWielkiejLiteryNazwySortowania=function(nazwa_sortowania,czy_od_poczatku) local ktoras_duza_litera=mw.ustring.match(nazwa_sortowania,((czy_od_poczatku and "^%s*" or "%s+").."%p*%u")); return ktoras_duza_litera and true or false; end; local function UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera) local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_wyrazy_do_usuwania_przez_sortowanie=kategorie_dane_modul.tablica_wyrazy_do_usuwania_przez_sortowanie; local tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie=kategorie_dane_modul.tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie; local tablica_dzielenia_elementowa_sortowania=kategorie_dane_modul.tablica_dzielenia_elementowa_sortowania; local tablica_wyrazowa_niealternatyw=kategorie_dane_modul.tablica_wyrazowa_niealternatyw; repeat local ile=0;local ile1=0;local ile2=0;local ile3=0; nazwa_sortowania,ile1=UsuwaneElemementyNazwySortowania(nazwa_sortowania,tablica_wyrazowa_niealternatyw,nil,false,true); nazwa_sortowania,ile2=UsuwaneElemementyNazwySortowania(nazwa_sortowania,tablica_kompletne_wyrazy_do_usuwania_przez_sortowanie,tablica_wyrazy_do_usuwania_przez_sortowanie,true,true); if(not ktoras_duza_litera)then nazwa_sortowania,ile3=UsuwaneElemementyNazwySortowania(nazwa_sortowania,nil,tablica_dzielenia_elementowa_sortowania,false,true); end; ile=ile1+ile2+ile3; until (ile==0); return nazwa_sortowania; end; function p.NazwaSortowaniaNazwyStrony(frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local nazwa_sortowania=args[1]; local techniczne_modul=require("Module:Techniczne"); nazwa_sortowania=techniczne_modul.UsuwanieZnakoweKontrolneNiewidzialne(nazwa_sortowania); if(not mw.ustring.match(nazwa_sortowania,"/"))then local kategorie_dane_modul=mw.loadData("Module:Kategorie/dane"); local tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania=kategorie_dane_modul.tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania; local _,_,ile_jest_na_poczatku=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^[%s_]*(.-)[%s_]*$",nil,tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania); if(ile_jest_na_poczatku>0)then nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; if(CzyPierwszyWyrazPrzezSortowanie(nazwa_sortowania))then return nazwa_sortowania,true;end; local czy_zmieniono; local stara_nazwa_sortowania=nazwa_sortowania; local nazwa_sortowania_po_minusie_lub_pausie=nazwa_sortowania; nazwa_sortowania,czy_zmieniono=WydzielonaNazwaSortowaniaPoMinusieLubPauzie(nazwa_sortowania); if(czy_zmieniono)then if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; else local _,_,ile_jest_na_poczatku=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"^[%s_]*(.-)[%s_]*$",nil,tablica_kompletne_wyrazowy_do_sortowania_bez_analizowania); if(ile_jest_na_poczatku>0)then nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; end; end; local ktoras_duza_litera=WyrazOdWielkiejLiteryNazwySortowania(nazwa_sortowania); local tablica_analizowanie_bez=kategorie_dane_modul.tablica_analizowanie_bez; local tablica_analizowanie_specjalne_wyrazy=kategorie_dane_modul.tablica_analizowanie_specjalne_wyrazy; local _,_,ile_wyrazy_specialne=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"%s+(%S+)",nil,tablica_analizowanie_bez,true); local _,_,ile_wyrazy_specialne_wyrazy=ZamienianieWyrazoweSzereguWyrazuKompleksowe(nazwa_sortowania,"%s+(%S+)",nil,tablica_analizowanie_specjalne_wyrazy,true); local nazwa_sortowania_przed_przyimkiem=(czy_zmieniono) and nazwa_sortowania_po_minusie_lub_pausie or nazwa_sortowania; local ile_przyimki;local nie_usuwaj_pierwszego_z_kolei_wyrazu; if((not ktoras_duza_litera)or(ile_wyrazy_specialne>0)or(ile_wyrazy_specialne_wyrazy>0))then local stara_nazwa_sortowania=nazwa_sortowania; nazwa_sortowania,ile_przyimki,nie_usuwaj_pierwszego_z_kolei_wyrazu=TekstPoPrzyimkuNazwySortowania(nazwa_sortowania); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; ile_przyimki=nil; nie_usuwaj_pierwszego_z_kolei_wyrazu=nil; end; end; if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; local nazwa_sortowania_temp=UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania_temp))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; ile_przyimki=nil; nie_usuwaj_pierwszego_z_kolei_wyrazu=nil; end; mw.log(nazwa_sortowania,"TYTAn123") ile=IleJestSpacjiNazwySortowania(nazwa_sortowania); if(ile>0)then local stara_nazwa_sortowania=nazwa_sortowania; if(not ktoras_duza_litera)then local tablica_wyrazowa_alternatyw=kategorie_dane_modul.tablica_wyrazowa_alternatyw; local _,_,ile_znalezione=ZamienianieWyrazoweSzereguWyrazuKompleksowe(stara_nazwa_sortowania,"%s+(%S+)",tablica_wyrazowa_alternatyw,nil); if(ile_znalezione>0)then local tablica_wyrazowa_gdy_alternatywy=kategorie_dane_modul.tablica_wyrazowa_gdy_alternatywy; local _,_,ile_specjalne_gdy_alternatywy=ZamienianieWyrazoweSzereguWyrazuKompleksowe(stara_nazwa_sortowania,"^%s*(%S+)",nil,tablica_wyrazowa_gdy_alternatywy); if(ile_specjalne_gdy_alternatywy==0)then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; end; end; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; end; nazwa_sortowania=UsuwanieNazwaSortowanie(nazwa_sortowania,ktoras_duza_litera); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; nazwa_sortowania=UsuwanieNazwaSortowanie(nazwa_sortowania); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=nazwa_sortowania_przed_przyimkiem; nazwa_sortowania=(not nie_usuwaj_pierwszego_z_kolei_wyrazu)and UsuwanieKolejnegoPierwszegoWyrazuNazwySortowania(nazwa_sortowania) or nazwa_sortowania; end; end; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; local stara_nazwa_sortowania=nazwa_sortowania; nazwa_sortowania=UsuwanieZnakoweInterpunkcjiWprowadzeniaNazwySortowania(nazwa_sortowania,false); if(CzyZnakiTylkoNiewidzialneInterpukcjiOrazKreskiDolnejNazwySortowania(nazwa_sortowania))then nazwa_sortowania=stara_nazwa_sortowania; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); end; nazwa_sortowania=p.NazwaElementuZWyrazemOdWielkichLiter(nazwa_sortowania); return nazwa_sortowania,true; end; nazwa_sortowania=UsuwanieSekwencjiArtykularnychLubZnakowychNawiasowychZnakoweInterpunkcjiWprowadzeniaNazwySortowaniaStrony(nazwa_sortowania); return nazwa_sortowania,false; end; return p; gj2qd0u29ihi7b0b8aw0j6oijityojv 4 63291 538577 538576 2026-03-30T12:01:52Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538577 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}},którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób pisząc bezpośrednio innaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablica do funkcji, w gtrzecim sposobie tą zmienną jest cala tablica, a czwartym jest zestaw parametrów. A czym się róż nia sie te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na rożne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 04mbfm4kmaevgwk52y2p8dtpu13oz41 538578 538577 2026-03-30T12:06:58Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538578 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}},którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób pisząc bezpośrednio innaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablica do funkcji, w gtrzecim sposobie tą zmienną jest cala tablica, a czwartym jest zestaw parametrów. A czym się róż nia sie te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na rożne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cpn3yuzmyi1cnlcz5ph0lp2y2jw94eo 538579 538578 2026-03-30T12:36:55Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538579 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}},którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sqoh134hcdhjg0c1o8hovupdodwacnm 538580 538579 2026-03-30T12:43:17Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538580 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5xpdda4srbk02n8eacybt6fm2wrbe3k 538581 538580 2026-03-30T13:00:45Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538581 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartość2=args["nazwa2"] or args[2]; local wartość3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, a {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jliduyatt4d1kkmm38abc0jp0mggpih 538582 538581 2026-03-30T13:03:48Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538582 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, a {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gofw553o1bsgs44jwnoy5rymf7i0iwu 538583 538582 2026-03-30T13:07:12Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 538583 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tohmv4uclzxdp60znad4itwgfm5hnm8 538584 538583 2026-03-30T13:11:22Z Persino 2851 /* {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} */ 538584 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)...end; </syntaxhighlight> == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> i74u2hzlk27eoonsnx5wnm61c03kxbu 538585 538584 2026-03-30T13:42:27Z Persino 2851 /* {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} */ 538585 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rd9nl34x6c9984g9jbnut9ewmclvmdr 538586 538585 2026-03-30T14:11:04Z Persino 2851 /* {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} */ 538586 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany jest: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> aj9mecbk1k11zuo66xcagno9dwt01n2 538587 538586 2026-03-30T14:12:48Z Persino 2851 /* {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} */ 538587 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 891uq8lesfofdr4xrkbqlfsvmzqgnde 538588 538587 2026-03-30T15:14:26Z Persino 2851 /* Funkcje wartości logicznej */ 538588 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składający się z nie znaków odstępu i niebędace ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania własnie w szablonach, jest: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składający się, przynajmniej któreśz nich, z nie znaków odstępu i niebędace ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania własnie w szablonach, jest: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|Not|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składający się z nie znaków odstępu i niebędacy ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania własnie w szablonach, jest: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="lua"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> s9vhfgoo1cbxfbvhofuj7ds7jomvsd4 538589 538588 2026-03-30T15:17:09Z Persino 2851 /* Funkcje wartości logicznej */ 538589 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składający się z nie znaków odstępu i niebędace ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składający się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędace ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składający się z nie znaków odstępu i niebędacy ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> psd8cfoiwj0te1jwugqbin6afwbf1rs 538590 538589 2026-03-30T15:19:18Z Persino 2851 /* Funkcje wartości logicznej */ 538590 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ton3e3ywce3wktb6a1oxzpez303ojaz 538591 538590 2026-03-30T15:23:52Z Persino 2851 /* {{Code|p.Or(frame)}} */ 538591 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kfjx31ueirx4wzdipurnnbabpvw0my3 538592 538591 2026-03-30T15:25:08Z Persino 2851 /* Funkcje wartości logicznej */ 538592 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> db4a5gbn070nl282sdumjryr48wvd7r 538593 538592 2026-03-30T15:27:31Z Persino 2851 /* Funkcje wartości logicznej */ 538593 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartość pusta. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sv8zw1etjr0ras3kadv1x8hfrqgt4gj 538594 538593 2026-03-30T15:28:31Z Persino 2851 /* {{Code|p.Not(frame)}} */ 538594 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> oxze673o3du2qtqc62c1ays1jtwkllu 538595 538594 2026-03-30T15:38:16Z Persino 2851 /* {{Code|p.Mniejszy(frame)}} */ 538595 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 4coyy0ag94udby28dl0blqjev2zh9do 538596 538595 2026-03-30T15:49:10Z Persino 2851 /* {{Code|p.IlePodano(frame)}} */ 538596 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występuje. == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> i4elgwfu919k740lf2dcz42srpiol5z 538597 538596 2026-03-30T15:50:10Z Persino 2851 /* {{Code|p.IlePodano(frame)}} */ 538597 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występuje. == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1d8enm01z6gf3x22ude4nfl6ef6gq8v 538598 538597 2026-03-30T15:50:50Z Persino 2851 /* {{Code|p.IlePodano(frame)}} */ 538598 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bh0qz1wnqgk6cncefjdwgl66c2pv0dv 538599 538598 2026-03-30T16:09:00Z Persino 2851 /* Metafunkcje i metatabele */ 538599 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["NAZWA1"]="wartosc1",["Nazwa1"]="wartość2",["NAZWA3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["nazwa1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery, ale powyżej podano wartość {{Code|nazwa1}}, wtedy obie wartości są sobie równe,a więc uzyskamy taki wynik. == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hmennwjkhq9dol0se4djcruddl71mvp 538600 538599 2026-03-30T16:09:30Z Persino 2851 /* {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} */ 538600 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["NAZWA1"]="wartosc1",["Nazwa2"]="wartość2",["NAZWA3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["nazwa1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery, ale powyżej podano wartość {{Code|nazwa1}}, wtedy obie wartości są sobie równe,a więc uzyskamy taki wynik. == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gxiiefub8l42r6pbwnfh7zm2xahzrgh 538601 538600 2026-03-30T16:10:28Z Persino 2851 /* {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} */ 538601 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["NAZWA1"]="wartosc1",["Nazwa2"]="wartość2",["NAZWA3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["nazwa1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery, ale powyżej podano wartość {{Code|nazwa1}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bru1by5f4s3lmv9m4ur9z5h3rhaj6zn 538602 538601 2026-03-30T16:13:02Z Persino 2851 /* Metafunkcje i metatabele */ 538602 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jflgraiszhjgmgw08y6t4o108ingyqj 538603 538602 2026-03-30T16:19:57Z Persino 2851 /* Iteratory */ 538603 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu()}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu()}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7fa0mcp05v9wwq4vlbt1bluulb4f57v 538604 538603 2026-03-30T16:20:35Z Persino 2851 /* Iteratory */ 538604 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu()|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu()}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> i09dz7oqr839xukb16bwmmukaukpdo9 538605 538604 2026-03-30T16:24:03Z Persino 2851 /* Iteratory */ 538605 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tjyv387i08qzvtlugh7zqey222xjml5 538606 538605 2026-03-30T16:35:02Z Persino 2851 /* {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} */ 538606 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metyatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metyatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2x8ziecszsgxu5ypw8khshx1s5hyysr 538607 538606 2026-03-30T16:38:56Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538607 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metyatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metyatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościomo pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> lyhsxfy5ftdm79xe46vlnynv68uebgk 538608 538607 2026-03-30T16:40:25Z Persino 2851 /* Iteratory */ 538608 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościomo pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1pe4q7ruesywm0mn9pknzygkdomkoit 538609 538608 2026-03-30T16:41:15Z Persino 2851 /* Iteratory */ 538609 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościomo pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cfbdcfsexhgez1q3oiwpmxhpsq5o2pj 538610 538609 2026-03-30T16:44:56Z Persino 2851 /* Iteratory */ 538610 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościomo pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> j1z6mfkiuzst78fo6l4sb7jumsmdind 538611 538610 2026-03-30T16:45:49Z Persino 2851 /* Iteratory */ 538611 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościomo pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cm7toi8ny1w1lb3pe5ngh9bi5y9kykm 538612 538611 2026-03-30T16:47:50Z Persino 2851 /* Iteratory */ 538612 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach i ich wartościom o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7d7n277d7plgwbmp4jxbrpxe17hmjpr 538613 538612 2026-03-30T16:50:39Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538613 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela) local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil) local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ak0hqrnisc3zd2hl7wy0pjrl6jeebeo 538614 538613 2026-03-30T16:52:31Z Persino 2851 /* Iteratory */ 538614 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela); local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil); local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> eswuwzf0jlvf3lz52bhc3i1g72dmyip 538615 538614 2026-03-30T16:54:04Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538615 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela); local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,nil); local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> thp8dhxubcef60box8547xhpqwetqwp 538616 538615 2026-03-30T17:05:27Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538616 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela); local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local funkcja_sortujaca=nil; local iter=parametry_modul.p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja_sortujaca); local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 39x27410j39ta5h44gltsw5po2nhecu 538617 538616 2026-03-30T17:07:29Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538617 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tabela); local __metatabelka={}; __metatabelka.__ipairs=function(t) return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja_sortujaca); local __metatabelka={}; __metatabelka.__pairs=function(t) return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3sick8ab4v6pio7zty4noe7vquulyy0 538618 538617 2026-03-30T17:12:48Z Persino 2851 /* Iteratory */ 538618 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local __metatabelka={}; __metatabelka.__ipairs=function(t) local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(t); return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ffgcrxlmu6z7htyyixsud7k1tusty83 538619 538618 2026-03-30T17:14:24Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538619 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych za pomocą: {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__ipairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local __metatabelka={}; __metatabelka.__ipairs=function(t) local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(t); return iter,t,0; end; setmetatable(tabela,__metatabelka); for name,value ipairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rid0896xsex4j0der1zjjwagcwpjsun 538620 538619 2026-03-30T17:22:29Z Persino 2851 /* {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} */ 538620 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2ap2oery6pqdudswixhtrlpemhrk55m 538621 538620 2026-03-30T17:25:30Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538621 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7ejgp8w754rsqhyuudnofcqcyw8b1mz 538622 538621 2026-03-30T17:28:23Z Persino 2851 /* Funkcje wartości minimalnej i maksymalnej */ 538622 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nlh5lajum7zfy6yczkquzetro8m61n2 538623 538622 2026-03-30T17:30:42Z Persino 2851 /* Funkcje wartości minimalnej i maksymalnej */ 538623 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych licz równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartosc maksymalna: {{Code|5}}. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> mbimsxux8nm4jz4q4dkafprx7faw3wp 538624 538623 2026-03-30T17:31:25Z Persino 2851 /* Funkcja biblioteczna */ 538624 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> or6u8qd8rc4f9sr5ds9jafibt13a46k 538625 538624 2026-03-30T17:36:39Z Persino 2851 /* Funkcje wartości minimalnej i maksymalnej */ 538625 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gastmdemrwu6syiq6dazu6omhq7urd3 538626 538625 2026-03-30T17:40:10Z Persino 2851 /* Iteratory */ 538626 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local iter=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return iter,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> mt20fjewkdf02nmh7hk9ohc5ebplexy 538627 538626 2026-03-30T17:41:56Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538627 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rpyhv9ixya4deizkmy75qoh23ejjzpj 538628 538627 2026-03-30T17:43:23Z Persino 2851 /* Iteratory */ 538628 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ff6ttwye46qnyk6vnj5suwcsf0pz9cc 538629 538628 2026-03-30T17:51:07Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 538629 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bdxjct5g4ta5c2degt16i19fwtwxeha 538630 538629 2026-03-30T17:57:22Z Persino 2851 /* Funkcje wartości minimalnej i maksymalnej */ 538630 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tą funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> io8ir8lhu0giza4oi5js1rg0yj1mayn 4 63361 538639 2026-03-31T11:11:29Z Persino 2851 Utworzono nową stronę "<noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do…" 538639 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> i1r7cto4gpo48gjjvacnihvmqko8wwn 538640 538639 2026-03-31T11:18:12Z Persino 2851 538640 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kab5icmzupsif7lmihitve867janda0 538641 538640 2026-03-31T11:27:35Z Persino 2851 538641 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje z {{Code|p.}} należą do tablicy transportu zwracanej przez moduł: {{Code|{{ld2|Strony}}}}, a bez niego to są funkcje lokalne oznaczone słowem {{Code|local}}. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> f0su8cuccqbq41n8bbf7n8i94rmm9mj 538642 538641 2026-03-31T11:28:23Z Persino 2851 538642 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje z {{Code|p.}} należą do tablicy transportu zwracanej przez moduł: {{Code|{{ld2|Strony}}}}, a bez niego to są funkcje lokalne w tym module oznaczone słowem {{Code|local}}. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ekj9wdkygyvwelgmqpvlq6ofg207k1f 538643 538642 2026-03-31T11:35:52Z Persino 2851 538643 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje z {{Code|p.}} należą do tablicy transportu zwracanej przez moduł: {{Code|{{ld2|Strony}}}}, a bez niego to są funkcje lokalne w tym module oznaczone słowem {{Code|local}}. Funkcje w tym module są wykorzystywane to sprawdzania, czy dany tekst spełnia jakieś warunki, funkcje bez {{Code|p.}} są wykorzystywane tylko w tym module, a z tym są bazą do do imolementacji modułu: {{Code|{{ld2|Sprawdź}}}}, w funkcji: {{Code|{{m|Sprawdź|Parametry}}}}, która służy do sprawdzania parametrów szablonów za pomocą funkcji w module: {{Code|{{ld2|Strony}}}}, ta funkcja też korzysta z innych funkcji z innych modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> pkz7xkw263xhxbtx633wfrni03lvql2 538644 538643 2026-03-31T11:44:58Z Persino 2851 538644 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje z {{Code|p.}} należą do tablicy transportu zwracanej przez moduł: {{Code|{{ld2|Strony}}}}, a bez niego to są funkcje lokalne w tym module oznaczone słowem {{Code|local}}. Funkcje w tym module są wykorzystywane do sprawdzania, czy dany tekst spełnia jakieś warunki, funkcje bez {{Code|p.}} są wykorzystywane tylko w tym module, a z tym są bazą do do imolementacji modułu: {{Code|{{ld2|Sprawdź}}}}, w funkcji: {{Code|{{m|Sprawdź|Parametry}}}}, która służy do sprawdzania parametrów szablonów za pomocą funkcji w module: {{Code|{{ld2|Strony}}}}, ta funkcja też korzysta z innych funkcji z innych modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fq5pir8hjwm32qlhq42pj76wvzdy5eg 538645 538644 2026-03-31T11:45:38Z Persino 2851 538645 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Strony}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local strony_modul=require("Module:Strony"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje z {{Code|p.}} należą do tablicy transportu zwracanej przez moduł: {{Code|{{ld2|Strony}}}}, a bez niego to są funkcje lokalne w tym module oznaczone słowem {{Code|local}}. Funkcje w tym module są wykorzystywane do sprawdzania, czy dany tekst spełnia jakieś warunki, funkcje bez {{Code|p.}} są wykorzystywane tylko w tym module, a z tym są bazą do imolementacji modułu: {{Code|{{ld2|Sprawdź}}}}, w funkcji: {{Code|{{m|Sprawdź|Parametry}}}}, która służy do sprawdzania parametrów szablonów za pomocą funkcji w module: {{Code|{{ld2|Strony}}}}, ta funkcja też korzysta z innych funkcji z innych modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. == {{Code|checkUri()}} == == {{Code|checkImageName()}} == == {{Code|findPlainHttp()}} == == {{Code|findAnyHttp()}} == == {{Code|findFile()}} == == {{Code|p.SprawdzanieURL(frame)}} == == {{Code|p.SprawdzanieNazwyPlikowe(frame)}} == == {{Code|p.ZnajdowanieNormalnychStronHttp(frame)}} == == {{Code|p.ZnajdowanieJakikolwiekStronHttp(frame)}} == == {{Code|p.ZnajdowaniePlikowe(frame)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> s77m8twe0simhpe31kw89o35yvlj002