Wikibooks plwikibooks https://pl.wikibooks.org/wiki/Wikibooks:Strona_g%C5%82%C3%B3wna MediaWiki 1.46.0-wmf.23 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 1352 539831 529020 2026-04-14T16:35:40Z Persino 2851 539831 wikitext text/x-wiki {{Podrozdział|Podręcznik|[[Życie codzienne]]<br>Jak żyć oszczędnie}} <small>[[Jak żyć oszczędnie/Okładka|Okładka]]</small> Podobno społeczeństwa rozwinięte stanowią 20% populacji, a zużywają 80% zasobów dostępnych na naszej planecie. Celem niniejszego podręcznika jest popularyzowanie oszczędnego trybu życia. Poruszono w nim między innymi problemy: oszczędzania wody, energii elektrycznej, papieru, jak również minimalizowania ilości produkowanych odpadów. Autorzy podręcznika wyrażają nadzieję, że będzie on rozwijany przez szersze grono ludzi &ndash; np. ekologów i może alterglobalistów. == Spis treści == # [[/Oszczędzanie/|Wstęp]] # [[/Minimalizowanie ilości odpadów/]] # [[/Odnawialne źródła energii/]] # [[/Inne/]] - zakupy, [https://www.vanderer.pl/blog/jak-zyc-tanio-skromnie-dobrze-oszczednie-wydajnie-szczesliwie-i-ekologicznie/ motoryzacja] # [[/Odżywianie/]] # [[/Bibliografia/]] k9zlu1s978sf0njg3euuwparahhrvho 539833 539831 2026-04-14T16:37:58Z Persino 2851 539833 wikitext text/x-wiki {{Rozdział|Podręcznik|[[Życie codzienne]]<br>Jak żyć oszczędnie}} <small>[[Jak żyć oszczędnie/Okładka|Okładka]]</small> Podobno społeczeństwa rozwinięte stanowią 20% populacji, a zużywają 80% zasobów dostępnych na naszej planecie. Celem niniejszego podręcznika jest popularyzowanie oszczędnego trybu życia. Poruszono w nim między innymi problemy: oszczędzania wody, energii elektrycznej, papieru, jak również minimalizowania ilości produkowanych odpadów. Autorzy podręcznika wyrażają nadzieję, że będzie on rozwijany przez szersze grono ludzi &ndash; np. ekologów i może alterglobalistów. == Spis treści == # [[/Oszczędzanie/|Wstęp]] # [[/Minimalizowanie ilości odpadów/]] # [[/Odnawialne źródła energii/]] # [[/Inne/]] - zakupy, [https://www.vanderer.pl/blog/jak-zyc-tanio-skromnie-dobrze-oszczednie-wydajnie-szczesliwie-i-ekologicznie/ motoryzacja] # [[/Odżywianie/]] # [[/Bibliografia/]] jsebll9tnpytgn2esl7dntf70290836 0 3761 539896 363804 2026-04-15T08:22:31Z Persino 2851 /* Styl */ 539896 wikitext text/x-wiki {{prognaw|PHP|[[../Autorzy/|Autorzy]]|}} == Dla twórców podręcznika == Niniejsza strona zbiera zalecenia dla autorów i standardy, w jakich pisany będzie podręcznik. Wszelkie uwagi i propozycje powinny być dyskutowane na stronie dyskusji. === Oprogramowanie === Wszystkie informacje powinny być w miarę aktualne i dotyczyć przynajmniej PHP 5.2/5.3 oraz MySQL 5.0. Biblioteki programistyczne opisujemy również w oparciu o ostatnią wersję. Jeżeli chcesz opisać jakąś bibliotekę, zgłoś to w dyskusji i zaproponuj spis treści. Wykaz propozycji można znaleźć na podstronie [[PHP/Inne/Do zrobienia|Do zrobienia]]. === Nawigacja === Na górze '''każdej''' podstrony prosimy zamieszczać następujący szablon: {{prognaw|PHP|[[../poprzedni/]]|[[../nastepny/]]}} którego kod jest następujący: <nowiki>{{subst:naw|PHP|poprzedni|nastepny}}</nowiki> Pola ''poprzedni'' oraz ''nastepny'' wypełniamy nazwami odpowiednich rozdziałów. Spis treści dostępny jest na stronie głównej podręcznika i wszelkie ważniejsze edycje należy uprzednio konsultować w dyskusji. === Styl === Podręcznik ten nie ma przypominać pracy zaliczeniowej ze studiów, ale dawać czytelnikowi możliwość zrozumienia czegoś. Nie unikajmy zatem przykładów, nawet tych banalnych oraz niekoniecznie związanych z programowaniem i często wracajmy do omówionych już wcześniej spraw. Definicje muszą być opatrzone konkretnym przykładem lub wyjaśnieniem, po co taka rzecz istnieje. Co jakiś czas tekst zachęca do samodzielnych eksperymentów i pokazuje, jak się za nie można zabrać. Wskazane są przydatne miejsca, adresy, techniki analizy kodu. Myślą przewodnią niniejszego podręcznika jest tzw. zasada złotego środka. Czytelnik po przeczytaniu powinien mieć wyrobiony nawyk pytania siebie, czy dana rzecz jest mu rzeczywiście potrzebna w oryginalnym kształcie. Wszystkie zagadnienia powinny mieć czytelnie wyszczególnione wady oraz zalety bez dołączanych twierdzeń sugerujących, że jest to panaceum na wszystkie problemy świata. Bardzo ważne jest graficzne rozłożenie tekstu na stronie, aby nie sprawiał wrażenia chaotycznego. Podczas edycji zawsze możemy podejrzeć, jak wprowadzone zmiany będą się prezentować. Unikajmy za wszelką cenę jednozdaniowych akapitów oraz nieracjonalnego dzielenia nimi jednolitej treści. Wskazane jest stosowanie list wypunktowanych lub numerowanych. Są bardziej przejrzyste niż normalny tekst, a przy tym zwięzłe. Używaj też ramek pomocniczych, których spis został zamieszczony niżej. Przykładowe kody źródłowe muszą być napisane czytelnie, w oparciu o identyczne formatowanie. # Nawiasy klamrowe otwieramy w nowej linijce. # Wcięcia trójznakowe. # W nazewnictwie posługujemy się camelStyle (tj. zmienne, funkcje itd. nazywamy jako ''nazwaFunkcji'', a nie ''nazwa_funkcji'' albo ''nazwafunkcji''). # Poszczególne części algorytmu staramy się separować linijką przerwy. # Kod musi być skomentowany, najlepiej komentarzami jednolinijkowymi. # Na końcu skryptu '''nie wstawiamy''' znaku <code><nowiki>?></nowiki></code> W kodach źródłowych staramy się unikać nieprawidłowych nawyków: # Niepotrzebne zmienne tymczasowe - jeżeli są potrzebne, wyjaśniamy dlaczego. Pamiętajmy o tym szczególnie przy omawianiu baz danych, gdzie zapytania piszemy bezpośrednio w funkcji/metodzie, bez żadnej pomocniczej zmiennej ''$query'', ''$zapytanie'' itd. # Wszystkie zmienne wcześniej inicjujemy. # W programowaniu obiektowym każdą metodę poprzedzamy przedrostkiem ''public'', ''private'' itd. # Nie stosujemy elementów składni typowych dla PHP 4 (np. ''var''), chyba że w opisach objaśniających różnice między wersjami. # Konstrukcje używane niezgodnie z przeznaczeniem powinny być omijane. Zaliczają się do nich m.in. ''funkcja("$zmienna");'' Kod musi być zawarty w znacznikach {{Tag|syntaxhighlight|parametry=lang="php"}}, np. <syntaxhighlight lang="php"><?php echo 'Hello world'; </syntaxhighlight> {{Uwaga|Większość rozdziałów została napisana jeszcze przed wprowadzeniem znacznika SOURCE do oprogramowania MediaWiki, dlatego korzystają ze starszego stylu. Jeśli możesz, zaktualizuj formatowanie.}} === Neutralny punkt widzenia === Zgodnie z zasadą Wikibooks, podręcznik powinien utrzymany być w konwencji ***neutralnego punktu widzenia***. Dotyczy to w szczególności takich rozdziałów, jak [[PHP/Inne/Edytory PHP|Edytory PHP]] czy [[Programowanie:PHP:Inne:Pomoc|Pomoc]], które wcale nie służą do reklamowania własnych aplikacji bądź serwisów WWW. Wszelkie kontrowersyjne materiały będą usuwane albo przeredagowane bardzo szybko. === Dobór bibliotek === W podręczniku, oprócz PHP, omawiane są też wybrane biblioteki programistyczne stworzone w tym języku. Ponieważ bibliotek jest dużo, a tylko niektóre z nich trzymają odpowiedni poziom, utworzony został zbiór warunków, jakie biblioteka musi spełnić, aby mogła być omówiona w podręczniku w trosce o jego jakość. # ''Obecność infrastruktury internetowej'' - system kontroli wersji, bugtracker, forum dla użytkowników # ''Przynajmniej rok aktywnego rozwoju'' - w ciągu roku od pojawienia się podręcznika biblioteka musi być cały czas aktywnie rozwijana (nowe wersje, poprawianie błędów, nowa funkcjonalność). Podstawą jest aktywność w repozytorium SVN lub innego systemu kontroli wersji. # ''Dostępne wydanie stabilne'' - biblioteka musi mieć przynajmniej jedno wydanie stabilne (tzw. wersja 1.0) aby mogła być umieszczona w podręczniku # ''Dostępna kompletna dokumentacja'' - biblioteki bez dokumentacji lub jedynie ze szczątkową dokumentacją (np. wygenerowany minimalistyczny APIDoc) nie mogą być umieszczone w podręczniku. # ''Wsparcie dla PHP 5.2/PHP 5.3'' - biblioteka musi ''bezproblemowo'' pracować na podanych wersjach PHP. # ''Konsultacja na stronie dyskusji podręcznika'' {{Uwaga|Rozdziały o bibliotekach niespełniających powyższych warunków będą '''usuwane'''!}} Pamiętaj, że podręcznik przede wszystkim poświęcony jest PHP. Rozdziały o bibliotekach mają jedynie pokazać zagadnienie i służyć za wstęp do danego tematu. Pełne omówienie biblioteki wykracza poza ramy tego podręcznika. === Podstrony === * [[PHP/Inne/Do zrobienia|Do zrobienia]] * [[PHP/Inne/Wytyczne|Wytyczne dla rozdziałów]] (czyli co każdy powinien zawierać) === Szablony === Oto wykaz szablonów używanych w podręczniku: {| border="1" cellpadding=3 cellspacing=0 style="margin: 0; border: 1px #aaaaaa solid; border-collapse: collapse; width: 100%; background-color: #ffffff" |- style="background-color: #efefef; font-size: 95%" ! width="25%" | Opis !! Kod !! Efekt |- | Ostrzeżenie czytelnika | {{S|Uwaga|Tekst ostrzeżenia}} | {{Uwaga|Tekst ostrzeżenia}} |- | Porada | {{S|Porada|Tekst porady}} | {{Porada|Tekst porady}} |- | Informacja | {{S|Infobox|Tekst informacji}} | {{Infobox|Tekst informacji}} |- | Definicja | {{S|Definicja|Tekst definicji}} | {{Definicja|Tekst definicji}} |- | Do zrobienia | {{S|TODO|co zrobić}} | {{TODO|co zrobić}} |- | Do zrobienia * do wstawiania w sekcji * stosować tylko w rozdziałach, w których większość tekstu jest napisana | {{S|RDoZrobienia}} | {{RDoZrobienia}} |- | Artykuł do poprawy | {{S|dopracować|powód}} | {{dopracować|powód}} |} sojqyaak0bd2rlw9cuon4acxtqf7t3y 0 4858 539897 363767 2026-04-15T08:24:29Z Persino 2851 /* Szablony */ 539897 wikitext text/x-wiki ==Wstępne uwagi== Ten podręcznik nie jest pomyślany, by od zera nauczyć C++. Tak, jak to jest napisane w [[C++/O podręczniku#Jak_czytać_ten_podręcznik|Jak czytać ten podręcznik]], zakładamy, że <font color="red">czytelnik jest mniej więcej zaznajomiony</font> z treścią podręcznika [[C]]. Co za tym idzie, nie należy wyjaśniać podstawowych pojęć, jak zmienna, funkcja, plik nagłówkowy, używanie kompilatora. Jeśli już, można krótko przypomnieć te informacje. Motywacją dla takiego postępowania jest, by nie marnować wysiłków na pisanie tego samego dwa razy - jest to oficjalne zalecenie, uzgodnione w dyskusji. == Jak edytować? == Jeśli nie masz doświadczenia z serwisami wiki i Wikibooks w szczególności, zachęcamy byś zajrzał do następujących modułów: * [[Pomoc:Jak edytować artykuły|Jak edytować artykuły]] * [[Wikibooks:Szablony|Szablony]] === Dodawanie nowych rozdziałów === Obecny spis treści jest wynikiem dyskusji i konsensusu wśród osób tworzących podręcznik. Jeśli chcesz wprowadzić w nim duże zmiany, lepiej będzie, jeśli najpierw napiszesz o tym na stronie dyskusji podręcznika i spytasz się innych o zdanie. Zaczynanie nieistniejących rozdziałów (zaznaczonych czerwonymi linkami) jest jak najbardziej ok, ale staraj się dostosować do krótkiej notki zawartej pod owym linkiem. === Indeks === Jeśli dopisujesz nowe, istotne pojęcie, umieść je w [[C++/Indeks|Indeksie]]. === Szablony === W podręczniku szeroko używane są następujące szablony: * {{S|Definicja}} * {{S|Uwaga}} * {{S|Porada}} * {{S|TODO}} * {{S|Nawigacja}} Szablony te (poza ostatnim) są tylko udogodnieniami i nie ma przymusu ich stosowania. Kolorowanie i wyróżnienie bloku kodu uzyskujemy przez umieszczenie kodu w tagach <tt>source</tt>, jak poniżej: <br/> {{Tag|syntaxhighlight|parametry=lang="cpp"|zawartość=<nowiki>int fun();</nowiki>}} === Kopiowanie tekstu z innych stron === Nie ma problemu z kopiowaniem tekstu (w tym kodu źródłowego) z innych źródeł na licencji [[w:GFDL|GFDL]] czy CC-BY-SA - wystarczy napisać w opisie zmian źródło, tak jak wymaga tego licencja. Problemem jest kopiowanie kodu źródłowego na licencji [[w:GPL|GPL]]. Obie licencje GNU są niekompatybilne, co oznacza, że takiego kodu nie można kopiować. Oczywiście wszelkie kopiowanie materiałów z innych stron, szczególnie Copyright, jest niedozwolone. == Koordynacja prac == {{TODO|Do zintegrowania z resztą lub usunięcia zostały stare rozdziały: [[Programowanie:C++:Klasy|Klasy]] i [[C++/Start|Start]].}} Ważna sprawa: jeśli nie możesz znaleźć czegoś w tym podręczniku, nie dodawaj tego do ToDo, nie dopisuj do spisu treści lecz sprawdź tutaj: [[C|podręcznik C]]. Jeśli zaś tego i tu nie ma, możesz spokojnie to dopisać, ewentualnie rozpocznij temat na stronie Dyskusji. == Konwencje == Styl i zasady używane w całym podręczniku zostały poniżej zebrane, z możliwością dodawania komentarzy, wątpliwości i wyjaśnień. Argumentem wybrania danej konwencji może być jej występowanie w większości innych podręczników czy dokumentacji. * Nagłówki Używamy nagłówków w stylu <iostream>, nie używamy wersji: <iostream.h>, pomija ona mechanizm przestrzeni nazw (std::). * Kod - wcięcia bloku {} W drodze [[Dyskusja:C%2B%2B#Kod|Dyskusji]] przyjęto i stosuje się styl wstawiania nawiasów klamrowych w nowej linii. Wcięcia przyjęto stosować długości 3 spacji. <syntaxhighlight lang="cpp">if (warunek) { wykonaj(); }</syntaxhighlight> * Kod - odstępy Często używanym stylem jest wstawianie spacji przed nawiasem, w takich wyrażeniach jak np.: <syntaxhighlight lang="cpp">if (cos) catch ()</syntaxhighlight> * Nazewnictwo Nie jest ani istotna ani narzucona zasada, ale pomoże uzyskać w miarę spójny styl w podręczniku. Podobny styl znajdziemy w innych publikacjach, w razie czego można zgłosić uwagi. <syntaxhighlight lang="cpp">void nazwa_funkcji() { Klasa nazwa_instancji; int nazwa_zmiennej; }</syntaxhighlight> * return - main Przeważa styl używania 'return 0' nad 'return EXIT_SUCCESS', pewnie ze względu na charakter programów - prostych przykładów. 021ro2owwdceqo1mxl9r5w4i2igf307 539898 539897 2026-04-15T08:25:20Z Persino 2851 /* Szablony */ 539898 wikitext text/x-wiki ==Wstępne uwagi== Ten podręcznik nie jest pomyślany, by od zera nauczyć C++. Tak, jak to jest napisane w [[C++/O podręczniku#Jak_czytać_ten_podręcznik|Jak czytać ten podręcznik]], zakładamy, że <font color="red">czytelnik jest mniej więcej zaznajomiony</font> z treścią podręcznika [[C]]. Co za tym idzie, nie należy wyjaśniać podstawowych pojęć, jak zmienna, funkcja, plik nagłówkowy, używanie kompilatora. Jeśli już, można krótko przypomnieć te informacje. Motywacją dla takiego postępowania jest, by nie marnować wysiłków na pisanie tego samego dwa razy - jest to oficjalne zalecenie, uzgodnione w dyskusji. == Jak edytować? == Jeśli nie masz doświadczenia z serwisami wiki i Wikibooks w szczególności, zachęcamy byś zajrzał do następujących modułów: * [[Pomoc:Jak edytować artykuły|Jak edytować artykuły]] * [[Wikibooks:Szablony|Szablony]] === Dodawanie nowych rozdziałów === Obecny spis treści jest wynikiem dyskusji i konsensusu wśród osób tworzących podręcznik. Jeśli chcesz wprowadzić w nim duże zmiany, lepiej będzie, jeśli najpierw napiszesz o tym na stronie dyskusji podręcznika i spytasz się innych o zdanie. Zaczynanie nieistniejących rozdziałów (zaznaczonych czerwonymi linkami) jest jak najbardziej ok, ale staraj się dostosować do krótkiej notki zawartej pod owym linkiem. === Indeks === Jeśli dopisujesz nowe, istotne pojęcie, umieść je w [[C++/Indeks|Indeksie]]. === Szablony === W podręczniku szeroko używane są następujące szablony: * {{S|Definicja}} * {{S|Uwaga}} * {{S|Porada}} * {{S|TODO}} * {{S|Nawigacja}} Szablony te (poza ostatnim) są tylko udogodnieniami i nie ma przymusu ich stosowania. Kolorowanie i wyróżnienie bloku kodu uzyskujemy przez umieszczenie kodu w tagach <tt>syntaxhighlight</tt>, jak poniżej: <br/> {{Tag|syntaxhighlight|parametry=lang="cpp"|zawartość=<nowiki>int fun();</nowiki>}} === Kopiowanie tekstu z innych stron === Nie ma problemu z kopiowaniem tekstu (w tym kodu źródłowego) z innych źródeł na licencji [[w:GFDL|GFDL]] czy CC-BY-SA - wystarczy napisać w opisie zmian źródło, tak jak wymaga tego licencja. Problemem jest kopiowanie kodu źródłowego na licencji [[w:GPL|GPL]]. Obie licencje GNU są niekompatybilne, co oznacza, że takiego kodu nie można kopiować. Oczywiście wszelkie kopiowanie materiałów z innych stron, szczególnie Copyright, jest niedozwolone. == Koordynacja prac == {{TODO|Do zintegrowania z resztą lub usunięcia zostały stare rozdziały: [[Programowanie:C++:Klasy|Klasy]] i [[C++/Start|Start]].}} Ważna sprawa: jeśli nie możesz znaleźć czegoś w tym podręczniku, nie dodawaj tego do ToDo, nie dopisuj do spisu treści lecz sprawdź tutaj: [[C|podręcznik C]]. Jeśli zaś tego i tu nie ma, możesz spokojnie to dopisać, ewentualnie rozpocznij temat na stronie Dyskusji. == Konwencje == Styl i zasady używane w całym podręczniku zostały poniżej zebrane, z możliwością dodawania komentarzy, wątpliwości i wyjaśnień. Argumentem wybrania danej konwencji może być jej występowanie w większości innych podręczników czy dokumentacji. * Nagłówki Używamy nagłówków w stylu <iostream>, nie używamy wersji: <iostream.h>, pomija ona mechanizm przestrzeni nazw (std::). * Kod - wcięcia bloku {} W drodze [[Dyskusja:C%2B%2B#Kod|Dyskusji]] przyjęto i stosuje się styl wstawiania nawiasów klamrowych w nowej linii. Wcięcia przyjęto stosować długości 3 spacji. <syntaxhighlight lang="cpp">if (warunek) { wykonaj(); }</syntaxhighlight> * Kod - odstępy Często używanym stylem jest wstawianie spacji przed nawiasem, w takich wyrażeniach jak np.: <syntaxhighlight lang="cpp">if (cos) catch ()</syntaxhighlight> * Nazewnictwo Nie jest ani istotna ani narzucona zasada, ale pomoże uzyskać w miarę spójny styl w podręczniku. Podobny styl znajdziemy w innych publikacjach, w razie czego można zgłosić uwagi. <syntaxhighlight lang="cpp">void nazwa_funkcji() { Klasa nazwa_instancji; int nazwa_zmiennej; }</syntaxhighlight> * return - main Przeważa styl używania 'return 0' nad 'return EXIT_SUCCESS', pewnie ze względu na charakter programów - prostych przykładów. 5rxm223jmr72wd0th5gjop4jnj6l5ck 0 12804 539893 389207 2026-04-15T08:16:46Z Persino 2851 /* Wyliczenia */ 539893 wikitext text/x-wiki ==Podział typów danych== Typy danych dzielimy na dwie podstawowe grupy: * Typy Wartościowe **proste (eng. primityve types , simple types) **wyliczeniowe (eng. enum types) **strukturalne (eng. struct types) *Typy Referencyjne **klasowe **interfejsowe **delegacyjne **tablicowe [[Specjalna:Wkład/89.65.85.38|89.65.85.38]] ([[Dyskusja wikipedysty:89.65.85.38|dyskusja]])a gdzie decimal? ==Typy proste== {|class="wikitable" !Nazwa !Rodzaj !Zakres Wartości |- |bool |wartość logiczna prawda/fałsz |true lub false |- |byte |rowspan=8|liczba całkowita |0 do 255 |- |sbyte | -128 do 127 |- |ushort |0 do 2¹⁶-1 |- |short | -2¹⁵ do 2¹⁵-1 |- |uint |0 do 2³²-1 |- |int | -2³¹ do 2³¹-1 |- |ulong |0 do 2⁶⁴-1 |- |long | -2⁶³ do 2⁶³-1 |- |float |rowspan=2|liczba zmiennoprzecinkowa |około -1,5*10^-45 do 3,4*10³⁸ |- |double |około -5,0*10^-324 do 1,7*10³⁰⁸ |- |char |colspan="2"|Pojedynczy znak Unicode |- |string |colspan="2"|Ciąg znaków Unicode |} ==Zmienne== Typy proste stosujemy bardzo często. Są one zwane zmiennymi. Zmienne deklarujemy oraz inicjalizujemy. Istnieją dwie metody, którymi możemy się posłużyć do tworzenia zmiennych. * Inicjalizacja oraz przypisanie wartości później, np. <syntaxhighlight lang=csharp>//... bardzo przydatny kod... int zmienna; //zmienną deklarujemy wpisując jej typ oraz nazwę. Nazwa jest niemal dowolna. Nie może ona być słowem kluczowym języka C#. //... więcej przydatnego kodu... zmienna = 10; //inicjalizujemy, czyli przypisujemy zmiennej wartość. </syntaxhighlight> * Inicjalizacja oraz przypisanie w jednej linijce <syntaxhighlight lang=csharp>//ponownie przydatny kod... int zmienna = 10; //tutaj łączymy obie konstrukcje. Tworzymy zmienną typu int i przypisujemy jej wartość 10. //więcej kodu. </syntaxhighlight> Jak posługiwać się zmiennymi? Jest to niezwykle proste. Aby użyć zmiennej musimy użyć jej nazwy - już nie wpisujemy typu przed zmienną! Ponownie istnieją dwie metody użycia zmiennej. <syntaxhighlight lang=csharp> string zmienna = "Lalala"; Console.Writeline("Moja zmienna to:"+zmienna); </syntaxhighlight> lub <syntaxhighlight lang=csharp> string zmienna = "Lalala"; Console.Writeline("Moja zmienna to:{0}", zmienna); </syntaxhighlight> ==Wyliczenia== Konstrukcja programistyczna zwana wyliczeniem jest przydatna. Nie stosuje jej się co chwilę, lecz świadomość, że coś takiego istnieje jest niezwykle ważna. Wyliczenie tworzymy tak: <syntaxhighlight lang=csharp> enum PoryRoku { Wiosna, Lato, Jesien, Zima } </syntaxhighlight> Co tutaj się dzieje? Tworzymy wyliczenie o nazwie PoryRoku. W środku tego wyliczenia są 4 elementy: Wiosna, Lato, Jesien i Zima. Każdemu z tych elementów jest przypisywana kolejna wartość liczbowa typu int. Czyli ten zapis jest równoważny zapisowi: <syntaxhighlight lang=csharp> enum PoryRoku { Wiosna = 0; Lato = 1; Jesien = 2; Zima = 3; } </syntaxhighlight> Możemy oczywiście takową kolejność zmienić: <syntaxhighlight lang=csharp> enum PoryRoku { Wiosna = 3; Lato =2; Jesien =4; Zima =1; } </syntaxhighlight> Albo rozpocząć od innej liczby, niż zero: <syntaxhighlight lang=csharp> enum PoryRoku { Wiosna = 1; //nowa wartość dla wiosny, oznacza nowe wartości dla reszty pór roku. Lato, //Lato = 2 Jesien, //Jesien = 3 Zima, //Zima = 4 } </syntaxhighlight> O strukturach będzie traktował jeden z kolejnych rozdziałów. {{prognaw|C_Sharp|[[../Pierwszy program/]]|[[../Klasa/]]}} 7ukghe602i5sezjiau8rllybhoen1da 0 27754 539894 399117 2026-04-15T08:19:15Z Persino 2851 /* _WinAPI_SetFocus */ 539894 wikitext text/x-wiki ==Co to jest WinAPI== Wg Wiki: Windows API, lub krócej: WinAPI – interfejs programistyczny systemu Microsoft Windows – jest to zbiór niezbędnych funkcji, stałych i zmiennych umożliwiających działanie programu w systemie operacyjnym Microsoft Windows. Zbiór ten jest bardzo obszerny i zawiera funkcje do tworzenia okien programów, elementów interfejsu graficznego, obsługi zdarzeń oraz umożliwiające dostęp do innych aplikacji, funkcji sieciowych czy sprzętu w komputerze. Mianem WinAPI określamy standardowe funkcje przychodzące wraz z plikami bibliotek DLL dostarczanymi z systemem, np. kernel32.dll, user32.dll, gdi32.dll, wsock32.dll, znajdującymi się w katalogu \Windows\System. Funkcje korzystające z WinAPI zawarte są w UDF'ie '''WinAPI.au3'''. Jest to największy UDF, ale część zawartych w nim funkcji dubluje funkcje wbudowane interpretera lub innych UDF'ów np.: '''GDIPlus.au3'''. W niniejszym opisie skupię się więc na funkcjach udostępniających nowe możliwości. ==Struktury (rekordy)== Niektóre funkcje znajdujące się w UDF'ie wykorzystują struktury jako parametry wywołania lub używają ich do zwracania wyników. Tworzenie takich struktur ułatwia plik '''StructureConstants.au3''', który zawiera predefiniowane stringi z opisem budowy typowych struktur. Nie musimy dołączać go dyrektywą '''#include''', gdyż robi to już sam UDF. Poniżej przykład tworzenia struktury zawierającej dane o wielkości i położeniu prostokątnego obszaru: <syntaxhighlight lang="autoit"> ;tworzenie struktury na podstawie stringu $tagRECT ;z biblioteki StructureConstants.au3 $tRect = DllStructCreate($tagRECT) ;nadanie wartości poszczególnym polom struktury DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) ;jeżeli zamiast samej struktury potrzebny jest wskaźnik do niej ;należy dodatkowo użyć funkcji odczytującej ten wskaźnik $ptrRect = DllStructGetPtr($tRect) ;dalsza część progamu </syntaxhighlight> Można też tak, wykorzystując skrócony sposób nadawania wartości pól struktury: <syntaxhighlight lang="autoit"> ;tworzenie struktury na podstawie stringu $tagRECT ;z biblioteki StructureConstants.au3 $tRect = DllStructCreate($tagRECT) ;nadanie wartości poszczególnym polom struktury (sposób uproszczony) $tRect.Left = 20 $tRect.Top = 50 $tRect.Right = 200 $tRect.Bottom = 200 ;dalsza część progamu </syntaxhighlight> Dokładniejszy opis dotyczący struktur i funkcji na nich operujących, w rozdziale [[AutoIt/Biblioteki DLL|'''Korzystanie z bibliotek DLL''']]. ===_WinAPI_PtInRect=== #include <WinAPI.au3> _WinAPI_PtInRect($tRect, $tPoint) Funkcja zwraca True gdy punkt znajduje się wewnątrz prostokątnego obszaru, lub False w przeciwnym przypadku. '''$tRect''' - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru '''$tPoint''' - struktura $tagPOINT zawierająca współrzędne sprawdzanego punktu Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> ;opis prostokąta $tRect = DllStructCreate($tagRECT) $tRect.Left = 20 $tRect.Top = 50 $tRect.Right = 200 $tRect.Bottom = 200 ;współrzędne sprawdzanego punktu $tPoint = DllStructCreate($tagPOINT) $tPoint.X = 120 $tPoint.Y = 120 If _WinAPI_PtInRect($tRect, $tPoint) Then $sTxt = "Punkt wewnątrz prostokąta" Else $sTxt = "Punkt na zewewnątrz prostokąta" EndIf MsgBox(4096, 'Test PtInRect', $sTxt) </syntaxhighlight> ===_WinAPI_RectIsEmpty=== #include <WinAPI.au3> _WinAPI_RectIsEmpty($tRect) Funkcja zwraca True gdy struktura opisująca prostokąt zawiera same zera, lub False w przeciwnym przypadku. '''$tRect''' - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> ;opis prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 0) DllStructSetData($tRect, "Top", 0) DllStructSetData($tRect, "Right", 0) DllStructSetData($tRect, "Bottom", 0) MsgBox(4096, 'RectIsEmpty', _ "Czy prostokąt jest pusty: " & _WinAPI_RectIsEmpty($tRect)) </syntaxhighlight> ===_WinAPI_PointFromRect=== #include <WinAPI.au3> _WinAPI_PointFromRect($tRect [, $fCenter = True]) Funkcja zwraca w postaci struktury $tagPOINT współrzędne środka, lub lewego górnego narożnika prostokątnego obszaru. '''$tRect''' - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru '''$fCenter''' - jeśli True zwraca punkt środkowy tego prostokąta, jeśli False jego współrzędne lewego górnego narożniku Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> ;opis prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) $tPoint = _WinAPI_PointFromRect($tRect) $iX = DllStructGetData($tPoint, 1) $iY = DllStructGetData($tPoint, 2) MsgBox(4096, "PointFromRect", _ "Punkt środkowy prostokąta:" & @LF & _ "x = " & $iX & @LF & "y = " & $iY) </syntaxhighlight> ===_WinAPI_GetXYFromPoint=== #include <WinAPI.au3> _WinAPI_GetXYFromPoint($tPoint, ByRef $iX, ByRef $iY) Funkcja zwraca przez referencję współrzędne punktu. '''$tPoint''' - struktura $tagPOINT zawierająca współrzędne punktu '''$iX''' i '''$iY''' - zmienne zawierające współrzędne punktu (nadpisywane przez referencję) Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $iX = 10, $iY = 10 ;opis prostokąta $tPoint = DllStructCreate($tagPOINT) DllStructSetData($tPoint, "X", 100) DllStructSetData($tPoint, "Y", 666) ;odczyt współrzędnych (przez referencję) _WinAPI_GetXYFromPoint($tPoint, $iX, $iY) MsgBox(4096, "GetXYFromPoint", _ "Odczytane współrzędne punktu:" & @LF & _ "x = " & $iX & @LF & "y = " & $iY) </syntaxhighlight> ==Funkcje związane z kontekstem urządzenia (DC)== Wszystkie funkcje graficzne WinAPI operują na kontekstach urządzeń. Podstawowe informacje o kontekstach można znaleźć w rozdziale [[AutoIt/Funkcje interfejsu GDI+|'''Funkcje interfejsu GDI+''']]. Teraz postaram się opisać temat nieco dokładniej, gdyż UDF dostarcza dużej ilości funkcji operujących na kontekstach i głębsze zrozumienie problemu będzie bardzo pomoncne w ich efektywnym wykorzystaniu. Twórcy Windows postanowili uprościć i ujednolicić operacje graficzne w systemie operacyjnym. Zamiast całej masy przypadków przesyłania informacji pomiędzy obiektami graficznymi (np. desktop -> okno, okno -> okno, okno -> bitmapa ... itd.) postanowili sprowadzić wszystko do jednego schematu: [Kontekst źródłowy] -> [Kontekst docelowy] Konteksty to jednak abstrakcje, same w sobie nie reprezentujące żadnego rzeczywistego obiektu. Dlatego kontekst musi być powiązany z rzeczywistym obiektem. Powiązanie to oznacza, że operacje wykonywane na kontekście będą jednocześnie wykonywane w tle na rzeczywistym obiekcie, bez konieczności zagłębiania się przez programistę w sam przebieg tego procesu. Wymiana informacji między kontekstami przebiega zawsze w ten sam sposób, natomiast przepływ informacji [obiekt] <-> [kontekst] jest realizowany przez OS bez udziału programisty: [Obiekt źródłowy]-[Kontekst źródłowy] -> [Kontekst docelowy]-[Obiekt docelowy] Oczywiście aby cały proces był możliwy do realizacji, konteksty i obiekty muszą być ze sobą zgodne (kompatybilne), tzn. zdolne do wymiany informacji. Rozpatrzmy dwa przykłady: '''1. Skopiowanie fragmentu desktopu do utworzonego okna GUI:''' Mamy do czynienia z dwoma istniejącymi obiektami, które są ze sobą z natury kompatybilne (wszak okno to nic innego jak część desktopu). Należy więc pobrać z systemu konteksty do obu obiektów (funkcja _WinAPI_GetDC), a następnie przesłać dane z kontekstu desktopu do kontekstu okna. Prosto i bez wnikania w szczegóły procesu. Przykładowy kod dla tego przypadku w opisie funkcji [[AutoIt/WinAPI#WinAPI_BitBlt|_WinAPI_BitBlt]]'''. '''2. Skopiowanie fragmentu desktopu do bitmapy:''' W tym przypadku istnieje tylko jeden obiekt (desktop), drugi obiekt (bitmapa) należy samodzielnie utworzyć. Rozpoczynamy od pobrania kontekstu do desktopu (_WinAPI_GetDC), następnie tworzymy nowy kontekst kompatybilny z kontekstem desktopu (_WinAPI_CreateCompatibleDC). Teraz tworzymy bitmapę kompatybilną z utworzonym kontekstem (_WinAPI_CreateCompatibleBitmap) i tworzymy powiązania pomiędzy kontekstem i bitmapą (_WinAPI_SelectObject). Mamy teraz powiązanie między desktopem, a bitmapą (poprzez kompatybilne konteksty) i możemy przesłać dane obrazu. Przykładowy kod dla tego przypadku w opisie funkcji [[AutoIt/WinAPI#WinAPI_CreateCompatibleBitmap|_WinAPI_CreateCompatibleBitmap]]. ===_WinAPI_GetDC=== #include <WinAPI.au3> _WinAPI_GetDC($hWnd) Funkcja odczytuje i zwraca kontekst do obszaru roboczego okna, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna Zwolnienie kontekstu za pomocą funkcji #_WinAPI_ReleaseDC. Przykład: <syntaxhighlight lang="autoit"> #Include <WinAPI.au3> $hWnd = GUICreate ("Test") $hDC = _WinAPI_GetDC($hWnd) MsgBox (0, "", "Uchwyt DC: " & $hDC) _WinAPI_ReleaseDC ($hWnd, $hDC) </syntaxhighlight> ===_WinAPI_GetWindowDC=== #include <WinAPI.au3> _WinAPI_GetWindowDC($hWnd) Funkcja odczytuje i zwraca kontekst do całego okna, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, jeżeli wstawimy 0 to będzie to oznaczało cały ekran (desktop). Zwolnienie kontekstu za pomocą funkcji '''_WinAPI_ReleaseDC '''. Przykład: <syntaxhighlight lang="autoit"> #Include <WinAPI.au3> $hWnd = GUICreate ("Test") $hDC = _WinAPI_GetWindowDC($hWnd) MsgBox (0, "", "Uchwyt DC: " & $hDC) _WinAPI_ReleaseDC ($hWnd, $hDC) </syntaxhighlight> ===_WinAPI_CreateCompatibleDC=== #include <WinAPI.au3> _WinAPI_CreateCompatibleDC($hDC) Funkcja tworzy kontekst zgodny z istniejącym kontekstem urządzenia. Zwraca uchwyt do tego kontekstu, lub 0 gdy wystąpił błąd. '''$hDC''' - uchwyt do istniejącego kontekstu DC Likwidacja kontekstu za pomocą funkcji '''_WinAPI_DeleteDC '''. ===_WinAPI_DeleteDC=== #include <WinAPI.au3> _WinAPI_DeleteDC($hDC) Funkcja likwiduje kontekst. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu DC Funkcji należy używać do usunięcia kontekstów utworzonych w skrypcie (_WinAPI_CreateCompatibleDC), a już nie wykorzystywanych, celem zwolnienia zasobów. ===_WinAPI_ReleaseDC=== #include <WinAPI.au3> _WinAPI_ReleaseDC($hWnd, $hDC) Funkcja zwalnia wcześniej pobrany kontekst. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna '''$hDC''' - uchwyt do kontekstu DC Funkcji należy używać do zwolnienia kontekstów pobranych w skrypcie (_WinAPI_GetDC lub _WinAPI_GetWindowDC), a już nie wykorzystywanych, celem zwolnienia zasobów. ===_WinAPI_SelectObject=== #include <WinAPI.au3> _WinAPI_SelectObject($hDC, $hGDIObj) Funkcja przypisuje obiekt do określonego kontekstu urządzenia. Zwraca uchwyt do pierwotnego obiektu (tego który był poprzednio przypisany do kontekstu), lub liczbę ujemną gdy wystąpił błąd. Obiekt musi być jednego z następujących typów: Bitmap, Brush, Font, Pen lub Region. '''$hDC''' - uchwyt do kontekstu DC '''$hGDIObj''' - uchwyt do przypisywanego obiektu Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> ;odczytanie kontekstu do desktopu $hDC = _WinAPI_GetWindowDC(0) ;tworzenie piór $hPen1 = _WinAPI_CreatePen($PS_SOLID, 12, 0x0000FF) $hPen2 = _WinAPI_CreatePen($PS_SOLID, 20, 0x00FF00) ;przypisanie pióra 1 do kontekstu _WinAPI_SelectObject($hDC, $hPen1) ;rysowanie linni w kontekście _WinAPI_DrawLine($hDC, 400, 500, 800, 700) ;przypisanie pióra 2 do kontekstu $hOld = _WinAPI_SelectObject($hDC, $hPen2) ;rysowanie linni w kontekście _WinAPI_DrawLine($hDC, 400, 700, 800, 400) Sleep(5000) ;jeżeli chcemy wrócić do poprzedniego przypisania _WinAPI_SelectObject($hDC, $hOld) ;zwolnienie zasobów _WinAPI_DeleteObject($hPen1) _WinAPI_DeleteObject($hPen2) _WinAPI_ReleaseDC(0, $hDC) </syntaxhighlight> ===_WinAPI_DeleteObject=== #include <WinAPI.au3> _WinAPI_DeleteObject ( $hObject ) Funkcja usuwa logiczne, obiekty takie jak pióro, pędzel, czcionka, bitmapa, region lub paleta. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hObject''' - uchwyt do usuwanego obiektu ===_WinAPI_BitBlt=== #include <WinAPI.au3> _WinAPI_BitBlt($hDestDC, $iXDest, $iYDest, $iWidth, $iHeight, $hSrcDC, $iXSrc, $iYSrc, $iROP) Funkcja kopiuje blok grafiki pomiędzy dwoma kontekstami urządzeń. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDestDC''' - uchwyt do kontekstu docelowego '''$iXDest''' i '''$iYDest''' - współrzędne lewego górnego narożnika wstawianego bloku w kontekście docelowym '''$iWidth''' i '''$iHeight''' - szerokość i wysokość kopiowanego bloku '''$hSrcDC''' - uchwyt do kontekstu źródłowego '''$iXSrc''' i '''$iYSrc''' - współrzędne lewego górnego narożnika kopiowanego bloku w kontekście źródłowym '''$iROP''' - kod operacji. Kody te określają, w jaki sposób dane kolorowego prostokątnego bloku kopiowanego z kontekstu źródłowego zostaną połączone z kolorami znajdującymi się w prostokącie docelowym: Nazwy stałych wg '''<WindowsConstants.au3>''' --------------------------------------------------------------------------------------------------------- $BLACKNESS = 0x00000042 | Wypełnia prostokąt docelowy używając koloru związanego z indeksem 0 | w palecie fizycznej (ten kolor jest czarny dla domyślnej palety). --------------------------------------------------------------------------------------------------------- $CAPTUREBLT = 0x40000000 | Zawiera wszystkie okna, które są nakładane na górze okna w obraz wynikowy. --------------------------------------------------------------------------------------------------------- $DSTINVERT = 0x00550009 | Negatyw prostokąta docelowego. --------------------------------------------------------------------------------------------------------- $MERGECOPY = 0x00C000CA | Łączy za pomocą operatora AND kolor prostokąta źródłowego z kolorem | aktualnie wybranego w $hDestDC pędzla. --------------------------------------------------------------------------------------------------------- $MERGEPAINT = 0x00BB0226 | Łączy za pomocą operatora OR negatyw prostokąta źródłowego | z kolorami prostokąta docelowego. --------------------------------------------------------------------------------------------------------- $NOMIRRORBITMAP = 0x80000000 | --------------------------------------------------------------------------------------------------------- $NOTSRCCOPY = 0x00330008 | Kopiuje negatyw prostokąta źródłowego do miejsca przeznaczenia. --------------------------------------------------------------------------------------------------------- $NOTSRCERASE = 0x001100A6 | Łączy za pomocą operatora OR kolory prostokąta źródłowego i docelowego, | a następnie wykonuje negatyw powstałych kolorów. --------------------------------------------------------------------------------------------------------- $PATCOPY = 0x00F00021 | Kopiuje pędzel aktualnie wybranego w $hDestDC, do bitmapy docelowej. --------------------------------------------------------------------------------------------------------- $PATINVERT = 0x005A0049 | Łączy za pomocą operatora XOR kolor pędzla aktualnie wybranego w $hDestDC, | z kolorami prostokąta docelowego. --------------------------------------------------------------------------------------------------------- $PATPAINT = 0x00FB0A09 | Łączy za pomocą operatora OR, kolor pędzla aktualnie wybranego w $hDestDC, | z negatywem prostokąta źródłowego. Wynik tej operacji jest połączony | za pomocą operatora OR, z kolorami prostokąta docelowego. --------------------------------------------------------------------------------------------------------- $SRCAND = 0x008800C6 | Łączy za pomocą operatora AND, kolory prostokąta źródłowego i docelowego. --------------------------------------------------------------------------------------------------------- $SRCCOPY = 0x00CC0020 | Kopiuje prostokąt źródłowy bezpośrednio do prostokąta docelowego. --------------------------------------------------------------------------------------------------------- $SRCERASE = 0x00440328 | Łączy za pomocą operatora AND, negatyw prostokąta docelowego | z kolorami prostokąta źródłowego. --------------------------------------------------------------------------------------------------------- $SRCINVERT = 0x00660046 | Łączy za pomocą operatora XOR, kolory prostokąta źródłowego i docelowego. --------------------------------------------------------------------------------------------------------- $SRCPAINT = 0x00EE0086 | Łączy za pomocą operatora OR, kolory prostokąta źródłowego i docelowego. --------------------------------------------------------------------------------------------------------- $WHITENESS = 0x00FF0062 | Wypełnia prostokąt docelowy używając koloru związanego z indeksem 1 | w palecie fizycznej (ten kolor jest biały dla domyślnej palety). Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> #include <GDIPlus.au3> #region tworzenie testowego obrazka $hGUI = GUICreate("GDI+", 400, 450) GUISetState() _GDIPlus_Startup() $hGraphic = _GDIPlus_GraphicsCreateFromHWND($hGUI) ;rysowanie elipsy domyślnym pędzlem _GDIPlus_GraphicsfillEllipse($hGraphic, 160, 100, 150, 100) $hBrush = _GDIPlus_BrushCreateSolid(0xB0FF0000) ;tworzenie pędzla _GDIPlus_GraphicsFillEllipse($hGraphic, 210, 30, 120, 250, $hBrush) Sleep(200) ;chwila na zakończenie tworzenia obrazka ;zwolnienie zasobów _GDIPlus_BrushDispose($hBrush) _GDIPlus_GraphicsDispose($hGraphic) _GDIPlus_Shutdown() #endregion tworzenie testowego obrazka $hGUIDC = _WinAPI_GetDC($hGUI) ;kontekst do obszaru roboczego GUI $hDC = _WinAPI_GetWindowDC(0) ;kontekst do desktopu ;kopiowanie fragmentów desktopu do GUI _WinAPI_BitBlt($hGUIDC, 0, 0, 300, 200, $hDC, 0, 0, $SRCCOPY) _WinAPI_BitBlt($hGUIDC, 100, 220, 250, 200, $hDC, 20, 0, $SRCAND) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_ReleaseDC (0, $hDC) _WinAPI_ReleaseDC ($hGUI, $hGUIDC) </syntaxhighlight> ===_WinAPI_SetTextColor=== #include <WinAPI.au3> _WinAPI_SetTextColor($hDC, $iColor) Funkcja ustawia kolor aktualnej czcionki w danym kontekście urządzenia. Zwraca kod poprzedniego koloru, lub -1 gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iColor''' - kod koloru w formacie RGB ===_WinAPI_SetBkColor=== #include <WinAPI.au3> _WinAPI_SetBkColor($hDC, $iColor) Funkcja ustawia kolor tła w danym kontekście urządzenia. Zwraca kod poprzedniego koloru, lub -1 gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iColor''' - kod koloru w formacie RGB ===_WinAPI_GetBkMode=== #include <WinAPI.au3> _WinAPI_GetBkMode($hDC) Funkcja zwraca tryb wyświetlania tła w danym kontekście urządzenia, lub 0 gdy wystąpił bład. Zwracane wartości: 1 ($TRANSPARENT) - tło przezroczyste 2 ($OPAQUE) - tło nieprzezroczyste '''$hDC''' - uchwyt do kontekstu ===_WinAPI_SetBkMode=== #include <WinAPI.au3> _WinAPI_SetBkMode($hDC, $iBkMode) Funkcja ustawia tryb wyświetlania tła w danym kontekście urządzenia. Zwraca kod poprzedniego trybu, lub 0 gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iBkMode''' - kod trybu wyświetlania tła: 1 ($TRANSPARENT) - tło przezroczyste 2 ($OPAQUE) - tło nieprzezroczyste Przykład: <syntaxhighlight lang="autoit"> #include <FontConstants.au3> #include <WinAPI.au3> #include <WindowsConstants.au3> Global $hDC, $hFont, $hFont_old, $iTextColor = 0xFF0000 HotKeySet("{ESC}", "_Exit") ;rejestrowanie funkcji zamykającej skrypt ;definiowanie prostokątnego obszaru, w którym będziemy wpisywali tekst $tRECT = DllStructCreate($tagRect) $tRECT.Left = 850 $tRECT.Top = 300 $tRECT.Right = 1250 $tRECT.Bottom = 550 $hDC = _WinAPI_GetDC(0) ;pobranie kontekstu do desktopu $hFont = _WinAPI_CreateFont(50, 0, 0, 0, 400, False, False, False, $DEFAULT_CHARSET, _ $OUT_DEFAULT_PRECIS, $CLIP_DEFAULT_PRECIS, $DEFAULT_QUALITY, 0, 'Arial') ;definicja fontów $hFont_old = _WinAPI_SelectObject($hDC, $hFont) ;zapamiętanie pierwotnych fontów i ustawienie nowych _WinAPI_SetBkColor($hDC, 0x000000) ;definicja koloru tła _WinAPI_SetBkMode($hDC, $TRANSPARENT) ;tło przezroczyste Do _WinAPI_SetTextColor($hDC, $iTextColor) ;ustawienie koloru tekstu _WinAPI_DrawText($hDC, "AUTOIT jest super!", $tRECT, $DT_CENTER) ;wypisanie tekstu Sleep(50) Until False ;funkcja zwalniająca zasoby i zamykająca skrypt Func _Exit() _WinAPI_SelectObject($hDC, $hFont_old) _WinAPI_DeleteObject($hFont) _WinAPI_ReleaseDC(0, $hDC) _WinAPI_InvalidateRect(0, 0) $tRECT = 0 Exit EndFunc </syntaxhighlight> ==Funkcje związane z tworzeniem i przetwarzaniem grafiki== ===_WinAPI_CreateBitmap=== #include <WinAPI.au3> _WinAPI_CreateBitmap($iWidth, $iHeight [, $iPlanes = 1 [, $iBitsPerPel = 1 [, $pBits = 0]]]) Funkcja tworzy bitmapę o określonej szerokości, wysokość, kolorze i formacie. Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd. '''$iWidth''' - szerokość bitmapy w pikselach '''$iHeight''' - wysokość bitmapy w pikselach '''$iPlanes''' - określa liczbę płaszczyzn kolorów używanych przez urządzenia '''$iBitsPerPel''' - liczba bitów potrzebnych do określenia barwy pojedynczego piksela '''$pBits''' - wskaźnik do tablicy danych kolorów używanych do ustawienia kolorów pikseli. Jeżeli parametr ten ma wartość 0, zawartość nowej bitmapy jest niezdefiniowana. ===_WinAPI_CreateCompatibleBitmap=== #include <WinAPI.au3> _WinAPI_CreateCompatibleBitmap($hDC, $iWidth, $iHeight) Funkcja tworzy bitmapę zgodną z określonym kontekstem urządzenia. Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu urządzenia '''$iWidth''' - szerokość bitmapy w pikselach '''$iHeight''' - wysokość bitmapy w pikselach Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <GDIPlus.au3> Const $SRCCOPY = 0x00CC0020 Local $iX = 500, $iY = 300 _GDIPlus_Startup() ;pobranie kontekstu desktopu $hDDC = _WinAPI_GetWindowDC(0) ;utworzenie kontekstu kompatybilnego do kontekstu desktopu $hCDC = _WinAPI_CreateCompatibleDC($hDDC) ;utworzenie bitmapy kompatybilnej z kontekstem urządzenia $hHBMP = _WinAPI_CreateCompatibleBitmap($hDDC, $iX, $iY) ;przypisanie bitmapy do kontekstu urządzenia _WinAPI_SelectObject($hCDC, $hHBMP) ;kopiowanie danych obrazu między kontekstami _WinAPI_BitBlt($hCDC, 0, 0, $iX, $iY, $hDDC, 30, 35, $SRCCOPY) ;tworzenie obiektu Bitmap z bitmapy $hBitmap = _GDIPlus_BitmapCreateFromHBITMAP($hHBMP) ;zapis bitmapy na dysku _GDIPlus_ImageSaveToFile($hBitmap, @ScriptDir & "\Test.jpg") ;zwolnienie zasobów _GDIPlus_BitmapDispose($hBitmap) _WinAPI_DeleteObject($hHBMP) _WinAPI_DeleteDC($hCDC) _GDIPlus_Shutdown() ;wyświetlenie utworzonego obrazka SplashImageOn("Test", @ScriptDir & "\Test.jpg", $iX, $iY) Sleep(5000) </syntaxhighlight> ===_WinAPI_CreateSolidBitmap=== #include <WinAPI.au3> _WinAPI_CreateSolidBitmap($hWnd, $iColor, $iWidth, $iHeight [, $bRGB = True]) Funkcja tworzy bitmapę typu solid (jednokolorową). Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, w którym wyświetlona będzie bitmapa '''$iColor''' - kolor bitmapy w formacie RGB '''$iWidth''' - szerokość bitmapy w pikselach '''$iHeight''' - wysokość bitmapy w pikselach '''$bRGB''' - jeżeli True to $iColor łącznie z kanałem alfa (0x00RRGGBB) Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> #include <WindowsConstants.au3> ;tworzenie GUI $hwnd = GUICreate("", 400, 300) $Button = GUICtrlCreateButton("", 100, 30, 100, 100, 0x40) $hDCDest = _WinAPI_GetDC($hwnd) ;kontekst do GUI ;tworzenie kompatybilnego kontekstu $hDCSource = _WinAPI_CreateCompatibleDC($hDCDest) ;tworzenie bitmapy typu solid $hHBitmap = _WinAPI_CreateSolidBitmap($hwnd, 0xff0000, 300, 300) ;przypisanie bitmapy do kompatybilnego kontekstu _WinAPI_SelectObject($hDCSource, $hHBitmap) GUISetState() Do $msg = GUIGetMsg() ;przeniesienie fragmentu bitmapy na przycisk _WinAPI_BitBlt($hDCDest, 102, 32, 96, 96, $hDCSource, 0, 0, $SRCCOPY) Until $msg = $GUI_EVENT_CLOSE Or $msg = $Button ;zwolnienie zasobów _WinAPI_ReleaseDC($hwnd, $hDCDest) _WinAPI_DeleteDC($hDCSource) _WinAPI_DeleteObject($hHBitmap) </syntaxhighlight> ===_WinAPI_CreatePen=== #include <WinAPI.au3> _WinAPI_CreatePen($iPenStyle, $iWidth, $nColor) Funkcja tworzy pióro (obiekt pen). Zwraca uchwyt do pióra, lub 0 gdy wystąpił błąd. '''$iPenStyle''' - styl pióra: PS_SOLID | linia ciągła PS_DASH | linia przerywana PS_DOT | linia punktowa PS_DASHDOT | na przemian kreska i kropka PS_DASHDOTDOT | na przemian kreska i dwie kropki PS_NULL | pióro jest niewidoczne PS_INSIDEFRAME | linia ciągła do wnętrza konturu zamkniętego '''$iWidth''' - szerokość linii rysowanej przez pióro (w pikselach) '''$nColor''' - kolor pióra w formacie BBGGRR (np. 0xAAF009) Aby użyć pióra należy przypisać go do kontekstu urządzenia za pomocą funkcji '''_WinAPI_SelectObject'''. Jeżeli wartość określona przez $nWidth jest większa niż 1, parametr $iPenStyle może być tylko PS_NULL, PS_SOLID lub PS_INSIDEFRAME. Niepotrzebne już pióro należy usunąć funkcją '''_WinApi_DeleteObject''' celem zwolnienia zasobów. Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> $hDC = _WinAPI_GetWindowDC(0) ;kontekst do desktopu ;tworzenie pędzla $hPen = _WinAPI_CreatePen($PS_SOLID, 12, 0x0000FF) ;przypisanie pędzla do kontekstu desktopu $obj = _WinAPI_SelectObject($hDC, $hPen) ;rysowanie linii _WinAPI_DrawLine($hDC, 400, 500, 900, 700) ;zmiana pędzla $hPen = _WinAPI_CreatePen($PS_DASHDOTDOT, -1, -1) $obj = _WinAPI_SelectObject($hDC, $hPen) _WinAPI_DrawLine($hDC, 400, 800, 900, 500) ; Sleep(2000) ;zwolnienie zasobów _WinAPI_DeleteObject($hPen) _WinAPI_ReleaseDC(0, $hDC) </syntaxhighlight> ===_WinAPI_CreateSolidBrush=== #include <WinAPI.au3> _WinAPI_CreateSolidBrush($nColor) Funkcja tworzy pędzel (obiekt brush)typu solid. Zwraca uchwyt do pędzla, lub 0 gdy wystąpił błąd. '''$nColor''' - kolor pędzla w formacie BBGGRR (np. 0xAAF009) Niepotrzebny już pędzel należy usunąć funkcją '''_WinApi_DeleteObject''' celem zwolnienia zasobów. Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("WinAPI", 400, 300) $hDC = _WinAPI_GetWindowDC($hGUI) GUISetState() ;tworzenie pędzla $hBrush = _WinAPI_CreateSolidBrush(0x0000FF) ;tworzenie struktury z danymi prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) ;odczyt wskaźnika do struktury $ptrRect = DllStructGetPtr($tRect) ;rysowanie ramki wokół prostokąta _WinAPI_FrameRect($hDC, $ptrRect, $hBrush) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hBrush) _WinAPI_ReleaseDC($hGUI, $hDC) </syntaxhighlight> ===_WinAPI_CreateFont=== #include <WinAPI.au3> _WinAPI_CreateFont($nHeight, $nWidth [, $nEscape = 0 [, $nOrientn = 0 [, $fnWeight = $FW_NORMAL [, $bItalic = False [, $bUnderline = False [, $bStrikeout = False [, $nCharset = $DEFAULT_CHARSET [, $nOutputPrec = $OUT_DEFAULT_PRECIS [, $nClipPrec = $CLIP_DEFAULT_PRECIS [, $nQuality = $DEFAULT_QUALITY [, $nPitch = 0 [, $szFace = 'Arial']]]]]]]]]]]]) Funkcja tworzy logiczną czcionkę o podanych cechach. Zwraca uchwyt do czcionki, lub 0 gdy wystąpił błąd. '''$nHeight''' - wysokość czcionki '''$nWidth''' - średnia szerokość czcionki '''$nEscape''' - kąt pochylenia linii tekstu w dziesiętnych stopnia '''$nOrientn''' - '''$fnWeight''' - waga czcionki: $FW_DONTCARE - 0 $FW_THIN - 100 $FW_EXTRALIGHT - 200 $FW_LIGHT - 300 $FW_NORMAL - 400 $FW_MEDIUM - 500 $FW_SEMIBOLD - 600 $FW_BOLD - 700 $FW_EXTRABOLD - 800 $FW_HEAVY - 900 '''$bItalic''' - italik True/False '''$bUnderline''' - podkreślenie True/False '''$bStrikeout''' - przekreślenie True/False '''$nCharset''' - zestaw znaków, następujące wartości są predefiniowane: $ANSI_CHARSET - 0 $BALTIC_CHARSET - 186 $CHINESEBIG5_CHARSET - 136 $DEFAULT_CHARSET - 1 $EASTEUROPE_CHARSET - 238 $GB2312_CHARSET - 134 $GREEK_CHARSET - 161 $HANGEUL_CHARSET - 129 $MAC_CHARSET - 77 $OEM_CHARSET - 255 $RUSSIAN_CHARSET - 204 $SHIFTJIS_CHARSET - 128 $SYMBOL_CHARSET - 2 $TURKISH_CHARSET - 162 $VIETNAMESE_CHARSET - 163 '''$nOutputPrec''' - '''$nClipPrec''' - '''$nQuality''' - '''$nPitch''' - '''$szFace''' - nazwa czcionki, np.: Arial, Arial Black, Courier, Courier New, Lucida Console, MS Sans Serif, Roman, Script, Times New Roman, itd. Niepotrzebną już czcionkę należy usunąć funkcją '''_WinApi_DeleteObject''' celem zwolnienia zasobów. ===_WinAPI_CreateFontIndirect=== #include <WinAPI.au3> _WinAPI_CreateFontIndirect($tLogFont) Funkcja tworzy logiczną czcionkę o podanych cechach. Zwraca uchwyt do czcionki, lub 0 gdy wystąpił błąd. '''$tLogFont''' - struktura $tagLOGFONT , określająca cechy czcionki logicznej. Pola struktury: Nazwa pola | Typ pola | Opis ------------------------------------------------------------------------------ Height | int | wysokość czcionki Width | int | średnia szerokość czcionki, 0 szerokość domyślna Escapement | int | kąt pochylenia linii tekstu w dziesiętnych stopnia Orientation | int | Weight | int | waga czcionki Italic | byte | czcionka pochylona - italik (True/False) Underline | byte | czcionka podkreślenie (True/False) StrikeOut | byte | czcionka przekreślenie (True/False) CharSet | byte | zestaw znaków OutPrecision | byte | ClipPrecision | byte | Quality | byte | PitchAndFamily | byte | FaceName | chr[32] | nazwa czcionki Można używać predefiniowanych stałych, tak jak w '''_WinAPI_CreateFont'''. Po wybraniu czcionki za pomocą SelectObject, GDI-font-Mapper próbuje dopasować czcionki logiczne do istniejącej czcionki fizycznej. Jeśli nie można znaleźć dokładne dopasowanie, zapewnia alternatywną czcionkę, której cechy są najbardziej zbieżne. Niepotrzebny już czcinkę należy usunąć funkcją '''_WinApi_DeleteObject''' celem zwolnienia zasobów. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <GUIConstants.au3> #include <GuiListBox.au3> #include <GuiButton.au3> $hGUI = GUICreate("_WinAPI_CreateFontIndirect", 350, 200) $hBtn = _GUICtrlButton_Create($hGUI, "Przycisk", 10, 10, 270, 34) $hListBox = _GUICtrlListBox_Create($hGUI, "Dyski logiczne:", 10, 50, 270, 150) _GUICtrlListBox_BeginUpdate($hListBox) _GUICtrlListBox_Dir($hListBox, "", $DDL_DRIVES, False) _GUICtrlListBox_EndUpdate($hListBox) ;tworzenie struktury $tLogFont = DllStructCreate($tagLOGFONT) DllStructSetData($tLogFont, "Height", 22) DllStructSetData($tLogFont, "Weight", 700) DllStructSetData($tLogFont, "Italic", True) DllStructSetData($tLogFont, "FaceName", 'Arial') ;tworzenie czcionek $hFont1 = _WinAPI_CreateFontIndirect($tLogFont) DllStructSetData($tLogFont, "Italic", False) DllStructSetData($tLogFont, "FaceName", 'Courier new') $hFont2 = _WinAPI_CreateFontIndirect($tLogFont) ;ustawienie czcionek _WinAPI_SetFont($hBtn, $hFont1) _WinAPI_SetFont($hListBox, $hFont2) GUISetState() Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hFont1) _WinAPI_DeleteObject($hFont2) </syntaxhighlight> ===_WinAPI_GetStockObject=== #include <WinAPI.au3> _WinAPI_GetStockObject($iObject) Funkcja zwraca uchwyt do jednego z wbudowanych szablonów pióra, pędzla, czcionki lub palety. Jeżeli wystąpił błąd zwracane jest 0. '''$iObject''' - wskazuje rodzaj obiektu. Parametr ten może być jedną z następujących wartości: $BLACK_BRUSH - pędzel czarny $DKGRAY_BRUSH - pędzel ciemnoszary $GRAY_BRUSH - pędzel szary $HOLLOW_BRUSH - pędzel Null, to samo co $NULL_BRUSH $LTGRAY_BRUSH - pędzel jasnoszary $NULL_BRUSH - pędzel Null (niemalujący) $WHITE_BRUSH - pędzel biały $BLACK_PEN - pióro czarne $NULL_PEN - pióro Null $WHITE_PEN - pióro białe $ANSI_FIXED_FONT - czcionka systemowa nieproporcjonalna (o stałej szerokości) $ANSI_VAR_FONT - czcionka systemowa proporcjonalna (o zmiennej szerokości) $DEVICE_DEFAULT_FONT - czcionka domyślna zależna od urządzenia $DEFAULT_GUI_FONT - czcionka domyślna dla obiektów interfejsu użytkownika $OEM_FIXED_FONT - czcionka nieproporcjonalna OEM $SYSTEM_FONT - czcionka systemowa $SYSTEM_FIXED_FONT - czcionka systemowa nieproporcjonalna stosowana w systemach Windows wcześniejszych niż 3.0 $DEFAULT_PALETTE - paleta domyślna Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("GetStockObject", 400, 300) $hDC = _WinAPI_GetWindowDC($hGUI) GUISetState() ;ciemnoszary pędzel $hBrush = _WinAPI_GetStockObject($DKGRAY_BRUSH) $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 380) DllStructSetData($tRect, "Bottom", 300) $ptrRect = DllStructGetPtr($tRect) _WinAPI_FillRect($hDC, $ptrRect, $hBrush) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hBrush) _WinAPI_ReleaseDC($hGUI, $hDC) </syntaxhighlight> ===_WinAPI_DrawText=== #include <WinAPI.au3> _WinAPI_DrawText($hDC, $sText, ByRef $tRect, $iFlags) Funkcja wstawia tekst do podanego kontekstu. Zwraca wysokość tekstu, lub 0 gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$sText''' - wstawiany tekst '''$tRect''' - struktura $tagRECT, zawierająca współrzędne prostokąta, w którym będzie wstawiony tekst '''$iFlags''' - flaga określająca jak ma być formatowany tekst: $DT_BOTTOM - wyrównanie tekstu do dolnej krawędzi prostokąta $DT_CALCRECT - oblicza szerokość i wysokość wymaganego prostokąta, wynik zwracany przez referencję w strukturze $DT_CENTER - centrowanie tekstu poziomo w prostokącie $DT_EDITCONTROL - jeżeli tekst jest wielowierszowy , to wiersz który nie mieści się w całości na wysokości prostokąta nie będzie wyświetlany, ma sens tylko w parze z $DT_WORDBREAK ($DT_WORDBREAK) + $DT_EDITCONTROL) $DT_END_ELLIPSIS - zastępuje część tekstu wielokropkiem, jeżeli nie mieści się w prostokącie $DT_EXPANDTABS - rozszerza znaki tabulacji, domyślny rozmiar tabulacji wynosi 8 znaków $DT_EXTERNALLEADING - $DT_HIDEPREFIX - nie jest wyświetlane podkreślenie znaku za prefiksem (&) $DT_INTERNAL - używa trzcinki systemowej do wyliczenia wielkości tekstu $DT_LEFT - wyrównanie tekstu do lewej $DT_MODIFYSTRING - $DT_NOCLIP - tekst nie jest przycinany gdy nie mieści się w prostokącie $DT_NOFULLWIDTHCHARBREAK - $DT_NOPREFIX - prefiks (&) jest wyświetlany jak zwykły znak $DT_PATH_ELLIPSIS - jeżeli tekst nie mieści się w prostokącie, a zawiera odwrotny ukośnik (\), część tekstu od ostatniego (\) w lewo jest zastąpiona wielokropkiem. Ten styl jest używany do wyświetlania ścieżek do plików. $DT_PREFIXONLY - wyświetla podkreślenie w miejscu znaku po prefiksie (&), inne znaki nie są wyświetlane $DT_RIGHT - wyrównanie tekstu do prawej $DT_RTLREADING - tekst od prawej do lewej, tylko dla czcionek arabskich i hebrajskich $DT_SINGLELINE - tekst jest wyświetlany w jednym wierszu, część niemieszcząca się jest przycinana $DT_TABSTOP - $DT_TOP - wyrównanie tekstu do górnej krawędzi prostokąta (tylko tekst w jednej linii) $DT_VCENTER - centrowanie tekstu w pionie (tylko tekst w jednej linii) $DT_WORDBREAK - niemieszczący się wyrazy przenoszone są do następnego wiersza, także znak końca wiersza powoduje jego złamanie, jeżeli $DT_WORDBREAK nie jest użyte to tekst jest zawsze wyświetlany w jednym wierszu $DT_WORD_ELLIPSIS - tnie dowolne słowo, które nie mieści się w prostokącie i dodaje wielokropek Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <WindowsConstants.au3> #include <FontConstants.au3> ;tworzenie struktury $tRECT = DllStructCreate($tagRect) DllStructSetData($tRECT, "Left", 500) DllStructSetData($tRECT, "Top", 250) DllStructSetData($tRECT, "Right", 1100) DllStructSetData($tRECT, "Bottom", 650) ;kontekst do desktopu $hDC = _WinAPI_GetDC(0) ;tworzenie trzcionki logicznej $hFont = _WinAPI_CreateFont(50, 0, 0, 0, 400, False, True, False, _ -1, -1, -1, -1, 0, 'Times New Roman') ;powiązanie czcionki z kontekstem $hOldFont = _WinAPI_SelectObject($hDC, $hFont) ;wypisanie tekstu _WinAPI_DrawText($hDC, "AutoIt is the best!", $tRECT, $DT_CENTER) Sleep(3000) ;zwolnienie zasobów _WinAPI_SelectObject($hDC, $hOldFont) _WinAPI_DeleteObject($hFont) _WinAPI_ReleaseDC(0, $hDC) _WinAPI_InvalidateRect(0, 0) </syntaxhighlight> ===_WinAPI_DrawLine=== #include <WinAPI.au3> _WinAPI_DrawLine($hDC, $iX1, $iY1, $iX2, $iY2) Funkcja rysuje w kontekście odcinek linii prostej. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iX1''' i '''$iY1''' - współrzędne, pozioma i pionowa początku odcinka '''$iX2''' i '''$iY2''' - współrzędne, pozioma i pionowa końca odcinka ===_WinAPI_LineTo=== #include <WinAPI.au3> _WinAPI_LineTo($hDC, $iX, $iY) Funkcja rysuje odcinek od bieżącego punktu do punktu o współrzędnych podanych jako parametry. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iX''' i '''$iY''' - współrzędne, pozioma i pionowa końca odcinka ===_WinAPI_MoveTo=== #include <WinAPI.au3> _WinAPI_MoveTo($hDC, $iX, $iY) Funkcja przesuwa aktualną pozycję do określonego punktu. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$iX''' i '''$iY''' - nowa współrzędne, pozioma i pionowa aktualnego pozycji Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> $hDC = _WinAPI_GetWindowDC(0) ;kontekst do pulpitu ;tworzenie pióra $hPen = _WinAPI_CreatePen($PS_SOLID, 3, 0xFF) ;przypisanie pióra do kontekstu $obj_orig = _WinAPI_SelectObject($hDC, $hPen) _WinAPI_DrawLine($hDC, 400, 300, 1000, 250) $del = 50 ;przesunięcie punktu aktualnego _WinAPI_MoveTo($hDC, 0, @DesktopHeight/2 - $del) For $x = $del To @DesktopWidth Step 50 $y = @DesktopHeight/2 + $del _WinAPI_LineTo($hDC, $x, $y) ;rysowanie linii $del = -$del Next Sleep(4000) ;powrót do pierwotnego pióra _WinAPI_SelectObject($hDC, $obj_orig) ;zwolnienie zasobów _WinAPI_DeleteObject($hPen) _WinAPI_ReleaseDC(0, $hDC) </syntaxhighlight> ===_WinAPI_DrawEdge=== #include <WinAPI.au3> _WinAPI_DrawEdge($hDC, $ptrRect, $nEdgeType, $grfFlags) Funkcja rysuje krawędzie prostokąta. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu kontekst '''$ptrRect''' - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta '''$nEdgeType''' - określa rodzaj krawędzi $BDR_RAISEDINNER - wypukła wewnętrzna krawędź $BDR_SUNKENINNER - wklęsła wewnętrzna krawędź $BDR_RAISEDOUTER - wypukła zewnętrzna krawędź $BDR_SUNKENOUTER - wklęsła zewnętrzna krawędź $EDGE_BUMP - kombinacja $BDR_RAISEDOUTER i $BDR_SUNKENINNER $EDGE_ETCHED - kombinacja $BDR_SUNKENOUTER i $BDR_RAISEDINNER $EDGE_RAISED - kombinacja $BDR_RAISEDOUTER i $BDR_RAISEDINNER $EDGE_SUNKEN - kombinacja $BDR_SUNKENOUTER i $BDR_SUNKENINNER '''$grfFlags''' - określa rodzaj obramowania. Parametr ten może być kombinacją następujących wartości: $BF_ADJUST - $BF_BOTTOM - dolna krawędź prostokąta $BF_BOTTOMLEFT - dolna i lewa krawędź prostokąta $BF_BOTTOMRIGHT - dolna i prawa krawędź prostokąta $BF_DIAGONAL - przekątna $BF_DIAGONAL_ENDBOTTOMLEFT - przekątna, od prawego-górnego do lewego-dolnego $BF_DIAGONAL_ENDBOTTOMRIGHT - przekątna, od lewego-górnego do prawego-dolnego $BF_DIAGONAL_ENDTOPLEFT - przekątna, od prawego-dolnego do lewego-górnego $BF_DIAGONAL_ENDTOPRIGHT - przekątna, od lewego-dolnego do prawego-górnego $BF_FLAT - obramowanie niewidoczne $BF_LEFT - lewa krawędź prostokąta $BF_MIDDLE - wnętrze prostokąta zamalowane (przekątne nie będą widoczne) $BF_MONO - obramowanie pojedynczą linią (wszystkie elementy jednakową) $BF_RECT - cały obwód od prostokąta $BF_RIGHT - prawa krawędź prostokąta $BF_SOFT - $BF_TOP - górna krawędź prostokąta $BF_TOPLEFT - górna i lewa krawędź prostokąta $BF_TOPRIGHT - górna i prawej krawędź prostokąta Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> #include <BorderConstants.au3> ;tworzenie GUI $hGUI = GUICreate("_WinAPI_DrawEdge", 410, 300) GUISetState() ;kontekst do przestrzeni roboczej okna $hDC = _WinAPI_GetDC($hGUI) ;tworzenie struktury z opisem prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) $ptrRect = DllStructGetPtr($tRect) ;rysowanie prostokąta _WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_RAISED , $BF_RECT) ;przesunięcie prostokąta poprzez zmianę wartości pól w strukturze DllStructSetData($tRect, "Left", 220) DllStructSetData($tRect, "Right", 400) ;rysowanie nowego prostokąta z przekątnymi _WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_DIAGONAL_ENDBOTTOMLEFT) _WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_DIAGONAL_ENDBOTTOMRIGHT) _WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_RECT) ;zwolnienie zasobów _WinAPI_ReleaseDC($hGUI, $hDC) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_DrawFrameControl=== #include <WinAPI.au3> _WinAPI_DrawFrameControl($hDC, $ptrRect, $nType, $nState) Funkcja rysuje elementy kontrolek określonego typu i stylu. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$tRect''' - struktura $tagRECT, zawierająca współrzędne prostokąta, w którym będzie wrysowany element '''$nType''' - typ rysowanego elementu. Parametr ten może być jedną z następujących wartości: $DFC_BUTTON - standardowy przycisk $DFC_CAPTION - pasek tytułu $DFC_MENU - pasek menu $DFC_POPUPMENU - element menu podręcznego $DFC_SCROLL - pasek przewijania '''$nState''' - określa początkowy stan ramki kontrolki: ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_BUTTON to $nState może być jedną z następujących wartości: ------------------------------------------------------------------------------------ $DFCS_BUTTON3STATE - przycisk 3-stanowy $DFCS_BUTTONCHECK - pole wyboru $DFCS_BUTTONPUSH - przycisk $DFCS_BUTTONRADIO - przycisk radio $DFCS_BUTTONRADIOIMAGE - Obraz dla przycisku opcji ( nonsquare potrzebuje obrazu ) $DFCS_BUTTONRADIOMASK - Maska dla przycisku opcji ( nonsquare potrzebuje maski ) ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_CAPTION , $nState może być jedną z następujących wartości: ------------------------------------------------------------------------------------ $DFCS_CAPTIONCLOSE - przycisk Zamknij $DFCS_CAPTIONHELP - przycisk Help $DFCS_CAPTIONMAX - przycisk Maksymalizuj $DFCS_CAPTIONMIN - przycisk Minimalizuj $DFCS_CAPTIONRESTORE - przycisk Restore ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_MENU , $ nState może być jedną z następujących wartości : ------------------------------------------------------------------------------------ $DFCS_MENUARROW - strzałka w prawo (rozwijanie podmenu) $DFCS_MENUARROWRIGHT - strzałka w lewo $DFCS_MENUBULLET - kropka $DFCS_MENUCHECK - zaznaczenia ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_SCROLL , $nState może być jedną z następujących wartości : ------------------------------------------------------------------------------------ $DFCS_SCROLLCOMBOBOX - strzałka w dół (pasek przewijania Combo box) $DFCS_SCROLLDOWN - strzałka w dół z paska przewijania $DFCS_SCROLLLEFT - strzałka w lewo z paska przewijania $DFCS_SCROLLRIGHT - Strzałka w prawo z paska przewijania $DFCS_SCROLLSIZEGRIP - uchwyt zmiany wielkości okna (prawy) $DFCS_SCROLLSIZEGRIPRIGHT - uchwyt zmiany wielkości okna (lewy) $DFCS_SCROLLUP - strzałka w górę z paska przewijania ------------------------------------------------------------------------------------ Następujących wartości mogą być dodane w celu ustawienia stanu elementu: ------------------------------------------------------------------------------------ $DFCS_CHECKED - przycisk jest zaznaczony $DFCS_FLAT - przycisk z płaskim obramowaniem $DFCS_INACTIVE - przycisk jest nieaktywny (szary) $DFCS_PUSHED - przycisk jest wciśnięty Przykład: <syntaxhighlight lang="autoit"> #include <FrameConstants.au3> #include <GUIConstantsEx.au3> #include <WinAPI.au3> ;tworzenie GUI $hGUI = GUICreate("_WinAPI_DrawFrameControl", 300, 300) GUISetState() $hDC = _WinAPI_GetDC($hGUI) $tRect = DllStructCreate($tagRECT) $ptrRect = DllStructGetPtr($tRect) $DFC = $DFC_CAPTION ;elementy paska tytułu SetPosSize($tRect, 20, 25, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONCLOSE) SetPosSize($tRect, 50, 25, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONHELP + $DFCS_INACTIVE) SetPosSize($tRect, 80, 25, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONMIN) SetPosSize($tRect, 110, 25, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONRESTORE + $DFCS_PUSHED) $DFC = $DFC_MENU ;elementy menu SetPosSize($tRect, 20, 65, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUARROW) SetPosSize($tRect, 50, 65, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUARROWRIGHT) SetPosSize($tRect, 80, 65, 22, 22) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUBULLET) SetPosSize($tRect, 110, 65, 40, 40) _WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUCHECK) ;zwolnienie zasobów _WinAPI_ReleaseDC($hGUI, $hDC) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE Func SetPosSize(ByRef $tRect, $x, $y, $w, $h) DllStructSetData($tRect, "Left", $x) DllStructSetData($tRect, "Top", $y) DllStructSetData($tRect, "Right", $x + $w) DllStructSetData($tRect, "Bottom", $y + $h) EndFunc </syntaxhighlight> ===_WinAPI_FillRect=== #include <WinAPI.au3> _WinAPI_FillRect($hDC, $ptrRect, $hBrush) Funkcja zamalowuje prostokąt podanym pędzlem. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$ptrRect''' - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta '''$hBrush''' - uchwyt do pędzla, lub powiększony o 1 kod jednego z kolorów systemowych. Kody kolorów systemowych od 0 do 30 (np. 13 to kolor wybranej pozycji w kontrolce). Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("WinAPI", 400, 300) $hDC = _WinAPI_GetWindowDC($hGUI) GUISetState() ;tworzenie pędzla (czerwony) $hBrush = _WinAPI_CreateSolidBrush(0x0000FF) ;tworzenie struktury z danymi prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) ;odczyt wskaźnika do struktury $ptrRect = DllStructGetPtr($tRect) ;zamalowanie prostokąta zdefiniowanym pędzlem _WinAPI_FillRect($hDC, $ptrRect, $hBrush) DllStructSetData($tRect, "Left", 210) DllStructSetData($tRect, "Right", 390) ;zamalowanie prostokąta standardowym kolorem _WinAPI_FillRect($hDC, $ptrRect, 29+1) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hBrush) _WinAPI_ReleaseDC($hGUI, $hDC) </syntaxhighlight> ===_WinAPI_FrameRect=== #include <WinAPI.au3> _WinAPI_FrameRect($hDC, $ptrRect, $hBrush) Funkcja rysuje ramkę wokół prostokątnego obszaru za pomocą podanego pędzla. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu '''$ptrRect''' - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta '''$hBrush''' - uchwyt do pędzla Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("WinAPI", 400, 300) $hDC = _WinAPI_GetWindowDC($hGUI) GUISetState() ;tworzenie pędzla $hBrush = _WinAPI_CreateSolidBrush(0x0000FF) ;tworzenie struktury z danymi prostokąta $tRect = DllStructCreate($tagRECT) DllStructSetData($tRect, "Left", 20) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 200) DllStructSetData($tRect, "Bottom", 200) ;odczyt wskaźnika do struktury $ptrRect = DllStructGetPtr($tRect) ;rysowanie ramki wokół prostokąta _WinAPI_FrameRect($hDC, $ptrRect, $hBrush) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hBrush) _WinAPI_ReleaseDC($hGUI, $hDC) </syntaxhighlight> ==Ikony i kursory== ===_WinAPI_DrawIcon=== #include <WinAPI.au3> _WinAPI_DrawIcon($hDC, $iX, $iY, $hIcon) Funkcja rysuje ikonę w określonym kontekście urządzenia. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu urządzenia '''$iX''' i '''$iY''' - współrzędne lewego górnego rogu ikony '''$hIcon''' - uchwyt do ikony ===_WinAPI_DrawIconEx=== #include <WinAPI.au3> _WinAPI_DrawIconEx($hDC, $iX, $iY, $hIcon [, $iWidth = 0 [, $iHeight = 0 [, $iStep = 0 [, $hBrush = 0 [, $iFlags = 3]]]]]) Funkcja rysuje ikonę w określonym kontekście urządzenia. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hDC''' - uchwyt do kontekstu urządzenia '''$iX''' i '''$iY''' - współrzędne lewego górnego rogu ikony '''$hIcon''' - uchwyt do ikony '''$iWidth''' i '''$iHeight''' - szerokość i wysokość ikony lub kursora, 0 szerokość domyślna '''$iStep''' - indeks kadru animowanego kursora, parametr jest ignorowany gdy ikona nie jest animowanym kursorem '''$hBrush''' - uchwyt pędzla do tworzenia migotania kursora '''$iFlags''' - parametr ten może być jedna z następujących wartości: 1 - rysowanie ikony lub kursora za pomocą maski 2 - rysowanie ikony lub kursora za pomocą obrazu 3 - rysowanie ikony lub kursora za pomocą maski i obrazu ===_WinAPI_LoadShell32Icon=== #include <WinAPI.au3> _WinAPI_LoadShell32Icon($iIconID) Funkcja odczytuje i zwraca uchwyt do ikony z pliku '''Shell32.dll''', lub 0 gdy wystąpił błąd. '''$iIconID''' - ID ikony w pliku '''Shell32.dll''' ===_WinAPI_CopyIcon=== #include <WinAPI.au3> _WinAPI_CopyIcon($hIcon) Funkcja tworzy duplikat ikony. Zwraca uchwyt do duplikatu, lub 0 gdy wystąpił błąd. '''$hIcon''' - uchwyt do kopiowanej ikony ===_WinAPI_DestroyIcon=== #include <WinAPI.au3> _WinAPI_DestroyIcon($hIcon) Funkcja usuwa z pamięci ikonę o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hIcon''' - uchwyt do usuwanej ikony Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> ;tworzenie GUI $hGUI = GUICreate("_WinAPI_DrawIcon", 400, 300) $hDC = _WinAPI_GetDC($hGUI) GUISetState() ;odczyt uchwytu do ikony $hIcon1 = _WinAPI_LoadShell32Icon(4) ;rysowanie ikony _WinAPI_DrawIcon($hDC, 20, 40, $hIcon1) ;tworzenie duplikatu ikony $hIcon2 = _WinAPI_CopyIcon($hIcon1) ;rysowanie ikony _WinAPI_DrawIconEx($hDC, 100, 40, $hIcon2, 160, 160) ;zwolnienie zasobów _WinAPI_ReleaseDC($hGUI, $hDC) _WinAPI_DestroyIcon($hIcon1) _WinAPI_DestroyIcon($hIcon2) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_SetCursor=== #include <WinAPI.au3> _WinAPI_SetCursor($hCursor) Funkcja ustawia kształt kursora. Zwraca uchwyt do poprzedniego kursora (o ile taki istniał), lub gdy nie było kursora. '''$hCursor''' - uchwyt do nowego kursora Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hCursor = 0x1000b $hGUI = GUICreate("_WinAPI_SetCursor", 400, 300) GUISetState() Do _WinAPI_SetCursor($hCursor) Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_GetCursorInfo=== #include <WinAPI.au3> _WinAPI_GetCursorInfo() Funkcja zwraca informacje o kursorze w postaci jednowymiarowej tablicy. Jeżeli wystąpi błąd makro @error<>0. Informacje w zwracanej tablicy: [0] - zawsze True [1] - True jeżeli kursor jest widoczny, w przeciwnym razie False [2] - uchwyt do kursora [3] - współrzędna pozioma kursora (globalna) [4] - współrzędna pionowa kursora (globalna) Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> ;odczyt informacji o kursorze $arr = _WinAPI_GetCursorInfo() ;tekst do wyświetlenia $Cursorinfo = " Zawsze : " & $arr[0] & @LF & _ " Widoczny?: " & $arr[1] & @LF & _ " Uchwyt : " & $arr[2] & @LF & _ " Pozycja X: " & $arr[3] & @LF & _ " Pozycja Y: " & $arr[4] ;tworzenie GUI $hGUI = GUICreate("Kursor", 200, 300) GUICtrlCreateLabel("DANE KURSORA", 58, 20,120,70) GUICtrlCreateLabel("IKONA KURSORA", 58, 150,120,70) $lab = GUICtrlCreateLabel($Cursorinfo, 40, 40,120,70) GUICtrlSetBkColor($lab,0xffff00) $hDC = _WinAPI_GetDC($hGUI) GUISetState() ;rysowanie ikony kursora _WinAPI_DrawIconEx($hDC, 60, 190, $arr[2], 100, 100) Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_GetIconInfo=== #include <WinAPI.au3> _WinAPI_GetIconInfo($hIcon) Funkcja zwraca w postaci jednowymiarowej tablicy informacje o określonej ikonie lub kursorze. Jeżeli wystąpi błąd makro @error<>0. Informacje w zwracanej tablicy: [0] - zawsze True [1] - True oznacza ikonę, False kursor [2] - współrzędna pozioma "hot spotu" kursora [3] - współrzędna pionowa "hot spotu" kursora [4] - uchwyt do maski ikony [5] - uchwyt do kolorowej bitmapy ikony Dla ikon "hot spot" jest zawsze w środku ikony. '''$hIcon''' - uchwyt do ikony lub jeden z poniższych kodów (dla W7): 0x10003 - normalna strzałka 0x10005 - pionowy kursor tekstowy (I) 0x10007 - koło (oczekiwanie na zakończenie operacji) 0x10009 - krzyż 0x1000B - strzałka w górę 0x1000D - dwustronna strzałka pochylona w prawo 0x1000F - dwustronna strzałka pochylona w prawo 0x10011 - dwustronna strzałka pozioma 0x10013 - dwustronna strzałka pionowa 0x10015 - krzyż z 4 strzałkami na ramionach 0x10017 - znak "STOP" 0x10019 - strzałka z kółkiem 0x1001B - strzałka ze znakiem zapytania 0x1001D - pióro 0x1001F - rączka 0x10021 - przycisk 0x10023 - strzałka z płytą 0x10025 - ikona aplikacji 0x10027 - ikona aplikacji 0x10029 - ostrzeżenie (wykrzyknik w żółtym trójkącie) 0x1002B - znak zapytania 0x1002D - krzyż w czerwonym kole 0x1002F - informacja (i w niebieskim kole) 0x10031 - ikona aplikacji 0x10033 - tarcza Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $kod=0x00002D ;odczyt informacji o kursorze $arr = _WinAPI_GetIconInfo($kod) ;tekst do wyświetlenia $IconInfo = " KOD=" & $kod & " (" & Ptr($kod) & ")" & @LF & _ "-------------------------------------" & @LF & _ " Zawsze : " & $arr[0] & @LF & _ " Ikona? : " & $arr[1] & @LF & _ " X hot spot : " & $arr[2] & @LF & _ " Y hot spot : " & $arr[2] & @LF & _ " Uchwyt maski: " & $arr[4] & @LF & _ " Uchwyt bitmapy: " & $arr[5] ;tworzenie GUI $hGUI = GUICreate("Kursor", 200, 305) GUICtrlCreateLabel("DANE IKONY", 58, 15,120,70) GUICtrlCreateLabel("WYGLĄD IKONY", 58, 180,120,70) $hLab = GUICtrlCreateLabel($IconInfo, 15, 35,170,135) GUICtrlSetBkColor($hLab,0xffff00) GUISetState() ;odczyt uchwytu do kontekstu przestrzeni roboczej okna $hDC = _WinAPI_GetDC($hGUI) ;rysowanie ikony _WinAPI_DrawIconEx($hDC, 50, 200, $kod, 100, 100) Do Sleep(50) _WinAPI_DrawIconEx($hDC, 50, 200, $kod, 100, 100) Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_ReleaseDC ($hGUI, $hDC) </syntaxhighlight> ===_WinAPI_ShowCursor=== #include <WinAPI.au3> _WinAPI_ShowCursor($fShow) Funkcja włącza/wyłącza wyświetlanie kursora w oknie skryptu. Zwraca nowy stan licznika wyświetlania, 0 - kursor wyświetlany, -1 - kursor ukryty. '''$fShow''' - True - kursor będzie wyświetlany, False - kursor będzie ukryty Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <GUIConstantsEx.au3> $iCount = 0 $hGui = GUICreate('Kursor widoczny', 350, 200) $iButton = GUICtrlCreateButton('Schowaj kursor', 10, 10, 330, 28) GUISetState() Do Switch GUIGetMsg() Case $iButton If $iCount Then $iCount = _WinAPI_ShowCursor(True) GUICtrlSetData($iButton, 'Schowaj kursor') WinSetTitle($hGui, '','Kursor widoczny, licznik = ' & $iCount) Else $iCount = _WinAPI_ShowCursor(False) GUICtrlSetData($iButton, 'Pokaż kursor') WinSetTitle($hGui, '','Kursor niewidoczny, licznik = ' & $iCount) EndIf Case $GUI_EVENT_CLOSE Exit EndSwitch Until False </syntaxhighlight> ===_WinAPI_SaveHICONToFile=== #include <WinAPIGdi.au3> _WinAPI_SaveHICONToFile ( $sFilePath, $vIcon [, $bCompress = False [, $iStart = 0 [, $iEnd = -1]]] ) Funkcja zapisuje ikonę na dysku. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd. '''$sFilePath''' - nazwa pliku ze ścieżką dostępu '''$vIcon''' - uchwyt do ikony lub tablica uchwytów ikon (jeżeli plik ma zawierać kolekcję ikon) '''$bCompress''' - określa czy użyć kompresji PNG przy zapisie ikon 32-bitowych. True - tak, False - nie '''$iStart''' - (tylko dla tablicy uchwytów) indeks pierwszej ikony do zapisu na dysku '''$iEnd''' - (tylko dla tablicy uchwytów) indeks ostatniej ikony do zapisu, domyślna wartość -1 oznacza ostatni indeks w tablicy Przykład: <syntaxhighlight lang="autoit"> #include <GDIPlus.au3> ;#include <WinAPIGdi.au3> nie jest konieczne, gdyż GDIPlus.au3 używa WinAPIGdi.au3 Opt('TrayMenuMode', 3) _GDIPlus_Startup() $sFile = FileOpenDialog("Wybierz obrazek", "", "Obrazy (*.bmp;*.png;*.jpg;*.gif;*.tif)") $hBitmap = _GDIPlus_ImageLoadFromFile($sFile) ;wczytanie bitmapy z dysku $hIcon = _GDIPlus_HICONCreateFromBitmap($hBitmap) ;tworzenie ikony z bitmapy _WinAPI_SaveHICONToFile('MyIcon.ico', $hIcon) ;zapisanie ikony na dysku ;zwolnienie zasobów _GDIPlus_BitmapDispose($hBitmap) _GDIPlus_Shutdown() ;tworzenie menu w tray'u $hMenu = TrayItemGetHandle(0) $idView = TrayCreateItem('Wyświetlenie obrazu ikony') TrayCreateItem('') $idExit = TrayCreateItem('Koniec') TraySetIcon('MyIcon.ico') ;zmiana ikony w tray'u TraySetState() TrayTip("Uwaga", 'Zmiana ikony w tray', 30) Do $idMsg = TrayGetMsg() If $idMsg = $idExit Then Exit if $idMsg = $idView Then SplashImageOn('', $sFile) Sleep(3000) SplashOff() EndIf Until 0 </syntaxhighlight> ==Regiony (Window Regions)== Każde okno w Windows ma zdefiniowany region, który jest widoczny dla użytkownika. Normalnie system operacyjny ustala ten region na całą powierzchnię okna. Istnieją jednak możliwość programowego ograniczenia widocznego obszaru okna poprzez zdefiniowanie własnego regionu. Po za tym regionem okno będzie niewidoczne i przeźroczyste. Samo ustalenie regionu nie ma wpływu na kształt całego okna, więc istnieje możliwość zmiany regonu w czasie działania skryptu. Samo okno nie zmienia się, zmienia się tylko kształt obszaru, w którym to okno jest widoczne. '''UWAGA:''' 1. Wszystkie współrzędne używane do definiowania regionów odnoszą się do całego okna, a nie jego przestrzeni roboczej. 2. Nie należy usuwać uchwytów regionu. System sam usuwa uchwyty, gdy nie są już potrzebne. Poniżej kilka funkcji do operowania regionami. ===_WinAPI_CreateRectRgn=== #include <WinAPI.au3> _WinAPI_CreateRectRgn($iLeftRect, $iTopRect, $iRightRect, $iBottomRect) Funkcja tworzy prostokątny region. Zwraca uchwyt do regionu, lub 0 gdy wystąpił błąd. '''$iLeftRect''' i '''$iTopRect''' - współrzędna lewego górnego narożnika prostokąta '''$iRightRect''' i '''$iBottomRect''' - współrzędna prawego dolnego narożnika prostokąta '''UWAGA:''' 1. Wszystkie współrzędne używane do definiowania regionów odnoszą się do całego okna, a nie jego przestrzeni roboczej. 2. Nie należy usuwać uchwytów regionu. System sam usuwa uchwyty, gdy nie są już potrzebne. ===_WinAPI_CreateRoundRectRgn=== #include <WinAPI.au3> _WinAPI_CreateRoundRectRgn($iLeftRect, $iTopRect, $iRightRect, $iBottomRect, $iWidthEllipse, $iHeightEllipse) Funkcja tworzy prostokątny region z zaokrąglonymi narożnikami. Zwraca uchwyt do regionu, lub 0 gdy wystąpił błąd. '''$iLeftRect''' i '''$iTopRect''' - współrzędna lewego górnego narożnika prostokąta '''$iRightRect''' i '''$iBottomRect''' - współrzędna prawego dolnego narożnika prostokąta '''$iRightRect''' i '''$iBottomRect''' - szerokość i wysokość elipsy tworzącej zaokrąglenia narożników ===_WinAPI_CombineRgn=== #include <WinAPI.au3> _WinAPI_CombineRgn($hRgnDest, $hRgnSrc1, $hRgnSrc2, $iCombineMode) Funkcja tworzy region będący kombinacją dwóch innych regionów. Zwraca typ powstałego regionu, lub 0 gdy wystąpił błąd. Zwracane wartości: $NULLREGION = 1 - region jest pusty $SIMPLEREGION = 2 - pojedynczy prostokąt $COMPLEXREGION = 3 - region kompleksowy zawierający więcej elementów Parametry: '''$hRgnDest''' - uchwyt do nowego regionu o wymiarach odpowiadających kombinacji dwóch pozostałych regionów. Region ten musi być wcześniej zdefiniowany w sposób dowolny, gdyż i tak zostanie nadpisany poprzez referencję. '''$hRgnSrc1''' i '''$hRgnSrc2''' - uchwyty do dwóch regionów, których kombinację tworzymy '''$iCombineMode''' - parametr określający sposób łączenia dwóch regionów. Może być jedną z poniższych wartości: $RGN_AND = 1 - część wspólna $RGN_OR = 2 - suma obu regionów $RGN_XOR = 3 - suma regionów z wyłączeniem części wspólnej $RGN_DIFF = 4 - drugi region odjęty od pierwszego $RGN_COPY = 5 - kopia pierwszego regionu ===_WinAPI_SetWindowRgn=== #include <WinAPI.au3> _WinAPI_SetWindowRgn($hWnd, $hRgn [, $bRedraw]) Funkcja aktywuj region o podanym uchwycie. Zwraca liczbę <>0 gdy sukces, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, którego dotyczyć będzie aktywowany region '''$hRgn''' - uchwyt do zdefiniowanego regionu '''$bRedraw''' - określa czy system ma odświeżyć okno po aktywowaniu regionu Przykład manipulowania regionami: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> ;tworzenie testowego GUI $hGUI = GUICreate(" Test Windows regions", 350, 210) GUISetBkColor(0xff0000, $hGUI) $btn_exit = GUICtrlCreateButton("Wyjście", 100, 150, 150) $lab = GUICtrlCreateLabel("To jest testowe okno", 55, 40,150,85) GUICtrlSetBkColor($lab,0xffff00) GUISetState(@SW_SHOW) $pos = WinGetPos($hGUI) $width = $pos[2] $height = $pos[3] ;okno normalne Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;region prostokątny $rgn = _WinAPI_CreateRectRgn(10, 10, 200, 200) _WinAPI_SetWindowRgn($hGUI, $rgn) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;region z zaokrąglonymi narożnikami $rgn = _WinAPI_CreateRoundRectRgn(0, 0, $width, $height,$width, $height) _WinAPI_SetWindowRgn($hGUI, $rgn) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;region kombinowany $rgn = _WinAPI_CreateRectRgn(0, 0, $width, $height) $rgn1 = _WinAPI_CreateRoundRectRgn(0, 0,200, 200,200, 200) $rgn2 = _WinAPI_CreateRoundRectRgn(220, 100,350,210, 50, 50) _WinAPI_CombineRgn($rgn, $rgn1, $rgn2, 2) _WinAPI_SetWindowRgn($hGUI, $rgn) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;region kombinowany z przezroczystym tłem $rgn = _WinAPI_CreateRectRgn(0, 0, $width, $height) $rgn2 = _WinAPI_CreateRectRgn(8, 28, 349, 232) $rgn3 = _WinAPI_CreateRectRgn(104, 176, 252, 199) _WinAPI_CombineRgn($rgn, $rgn, $rgn2, 3) _WinAPI_CombineRgn($rgn, $rgn, $rgn3, 2) _WinAPI_SetWindowRgn($hGUI, $rgn) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit </syntaxhighlight> ===_WinAPI_GetWindowRgn=== #include <WinAPI.au3> _WinAPI_GetWindowRgn($hWnd, $hRgn) Funkcja odczytuje uchwyt do aktualnie ustawionego regionu. Zwraca typ regionu (jak '''_WinAPI_CombineRgn'''), lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, którego region będzie odczytywany '''$hRgn''' - uchwyt do regionu, może być dowolny, gdyż zostanie nadpisany przez referencję odczytywanym regionem okna. Najprościej stworzyć dowolny region funkcją '''_WinAPI_CreateRectRgn'''. Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> ;tworzenie testowego GUI $hGUI = GUICreate(" Test Windows regions", 350, 210) GUISetBkColor(0xff0000, $hGUI) $btn_exit = GUICtrlCreateButton("Wyjście", 100, 150, 150) $lab = GUICtrlCreateLabel("To jest testowe okno", 55, 40,150,85) GUICtrlSetBkColor($lab,0xffff00) GUISetState(@SW_SHOW) ;okno wyjściwe Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;ustalenie regionu _WinAPI_SetWindowRgn($hGUI, _WinAPI_CreateRectRgn(0, 0, 200, 210)) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;tworzenie dowolnego regionu $hrgn = _WinAPI_CreateRectRgn(0, 0, 0, 0) ;odczyt uchwytu aktualnego regionu _WinAPI_GetWindowRgn($hGUI, $hrgn) ;zmiana regionu _WinAPI_SetWindowRgn($hGUI, _WinAPI_CreateRectRgn(0, 0, 200, 20)) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit ;odtworzenie regionu _WinAPI_SetWindowRgn($hGUI, $hrgn) Do $msg = GUIGetMsg() Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit </syntaxhighlight> ==Funkcje związane z oknami i ekranem== W systemie Windows istnieje wiele różnych typów okien. Okna '''overlapped''' to standardowe okna z ramką i napisem tytułowym. Okna typu '''child''' to okna potomne, wyświetlane w obszarze roboczym swojego okna rodzica. Kiedy przesuwasz po ekranie okno rodzica, to razem z nim przesuwają się wszystkie jego okna-dzieci. Okna typu '''popup''' to również okna potomne, wyświetlane jednak niezależnie od położenia i rozmiarów okna rodzica. Okna potomne znajdują się zawsze nad swoim oknem-rodzicem (nie mogą być przez nie zasłonięte). Również obiekty sterujące typu: przyciski, listbox'y, paski przewijania i inne opisane niżej obiekty są oknami. ===_WinAPI_CreateWindowEx=== #include <WinAPI.au3> _WinAPI_CreateWindowEx($iExStyle, $sClass, $sName, $iStyle, $iX, $iY, $iWidth, $iHeight, $hParent [, $hMenu = 0 [, $hInstance = 0 [, $pParam = 0]]]) Funkcja zwraca uchwyt do tworzonego okna, lub 0 gdy wystąpił błąd. '''$iExStyle''' - rozszerzony styl okna '''$sClass''' - nazwa klasy okna, np.: BUTTON, COMBOBOX, EDIT, LISTBOX, MDICLIENT, SCROLLBAR, STATIC '''$sName''' - nazwa okna '''$iStyle''' - styl okna '''$iX''', '''$iY''' - współrzędne lewego górnego narożnika okna '''$iWidth''', '''$iHeight''' - szerokość i wysokość okna '''$hParent''' - uchwyt okna nadrzędnego '''$hMenu''' - uchwyt do menu lub numer kontrolki '''$hInstance''' - uchwyt instancji '''$pParam''' - parametr używany przy tworzeniu okna MDI (Multiple Document Interface) UWAGA: $iExStyle i $iStyle wg rozdziału [[AutoIt/GUI#Tworzenie okna GUI|AutoIt / GUI / Opis funkcji GUI / Tworzenie okna GUI]]. ===_WinAPI_DestroyWindow=== #include <WinAPI.au3> _WinAPI_DestroyWindow($hWnd) Funkcja niszczy okno o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <WindowsConstants.au3> #include <GUIConstantsEx.au3> $hGui = GUICreate('CreateWindowEx', 240, 60) $hEdit = _WinAPI_CreateWindowEx($WS_EX_CLIENTEDGE, "Edit", "Mały test", _ BitOR($WS_CHILD, $WS_VISIBLE), 10, 10, 140, 22, $hGui) $hButton = _WinAPI_CreateWindowEx($WS_EX_DLGMODALFRAME, "Button", "Przycisk", _ BitOR($WS_CHILD, $WS_VISIBLE), 160, 10, 70, 22, $hGui) GUISetState() Do Until GUIGetMsg() = $GUI_EVENT_CLOSE _WinAPI_DestroyWindow($hEdit) Sleep(1000) _WinAPI_DestroyWindow($hButton) Sleep(1000) </syntaxhighlight> ===_WinAPI_ShowWindow=== #include <WinAPI.au3> _WinAPI_ShowWindow ( $hWnd [, $iCmdShow = 5] ) Funkcja ustawia określony stan wyświetlanego okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt okna '''$iCmdShow''' - określa w jaki sposób wyświetlane jest okno: @SW_HIDE - ukrywa okno @SW_MAXIMIZE - maksymalizuje okno @SW_MINIMIZE - minimalizuje okno i aktywuje następne w kolejności wg kolejności nakładania (Z-order) @SW_RESTORE - wyświetla i aktywuje okno @SW_SHOW - wyświetla i aktywuje okno w domyślnej wielkości i położeniu @SW_SHOWDEFAULT - ustawia stan wyświetlania okna w oparciu o SW_flag określonej w strukturze STARTUPINF @SW_SHOWMAXIMIZED - wyświetla i aktywuje zmaksymalizowane okno @SW_SHOWMINIMIZED - wyświetla i aktywuje zminimalizowane okno @SW_SHOWMINNOACTIVE - wyświetla zminimalizowane okno @SW_SHOWNA - wyświetla okno z aktualnymi ustawieniami @SW_SHOWNOACTIVATE - wyświetla w domyślnej wielkości i położeniu @SW_SHOWNORMAL - wyświetla i aktywuje okno ===_WinAPI_RedrawWindow=== #include <WinAPI.au3> _WinAPI_RedrawWindow ( $hWnd [, $tRECT = 0 [, $hRegion = 0 [, $iFlags = 5]]] ) Funkcja aktualizuje określony prostokąt lub region, w obszarze roboczym danego okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt okna '''$tRect''' - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru, parametr jest ignorowany, gdy w $hRegion podano uchwyt do zdefiniowanego regionu aktualizacji '''$hRegion''' - uchwyt do zdefiniowanego regionu aktualizacji, jeżeli $hRegion=0 i $tRect=0 aktualizowany jest cały obszar klienta '''$iFlags''' - flaga definiująca sposób przerysowania okna, może być kombinacją następujących wartości (zdefiniowane w <WindowsConstants.au3>): $RDW_ERASE - Causes the window to receive a WM_ERASEBKGND message when the window is repainted $RDW_FRAME - Causes any part of the nonclient area of the window that intersects the update region to receive a WM_NCPAINT message. $RDW_INTERNALPAINT - Causes a WM_PAINT message to be posted to the window regardless of whether any portion of the window is invalid. $RDW_INVALIDATE - Invalidates $tRECT or $hRegion. If both are 0, the entire window is invalidated. $RDW_NOERASE - Suppresses any pending $WM_ERASEBKGND messages $RDW_NOFRAME - Suppresses any pending $WM_NCPAINT messages $RDW_NOINTERNALPAINT - Suppresses any pending internal $WM_PAINT messages $RDW_VALIDATE - Validates $tRECT or $hRegion $RDW_ERASENOW - Causes the affected windows to receive $WM_NCPAINT and $WM_ERASEBKGND messages, if necessary, before the function returns $RDW_UPDATENOW - Causes the affected windows to receive $WM_NCPAINT, $WM_ERASEBKGND, and $WM_PAINT messages, if necessary, before the function returns. $RDW_ALLCHILDREN - Includes child windows in the repainting operation $RDW_NOCHILDREN - Excludes child windows from the repainting operation ===_WinAPI_InvalidateRect=== #include <WinAPI.au3> _WinAPI_InvalidateRect($hWnd [, $tRect = 0 [, $fErase = True]]) Funkcja powoduje odświeżenie prostokątnego obszaru okna. '''$hWnd''' - uchwyt okna, 0 oznacza cały desktop '''$tRect''' - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru '''$fErase''' - określa czy ma być kasowane tło okna, True - tło kasowane, False - tło bez zmian Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> #include <GDIPlus.au3> Local $tRect = DllStructCreate($tagRECT) $hGUI = GUICreate("Okno testowe", 400, 450, 200, 200) GUISetState() test_picture() MsgBox(0, "", "Odświerzenie obszaru wewnątrz okna") DllStructSetData($tRect, "Left", 100) DllStructSetData($tRect, "Top", 50) DllStructSetData($tRect, "Right", 250) DllStructSetData($tRect, "Bottom", 300) _WinAPI_InvalidateRect($hGui, $tRect) MsgBox(0, "", "Odświerzenie całego okna") _WinAPI_InvalidateRect($hGui, 0) Sleep(3000) Func test_picture() $hGUIDC = _WinAPI_GetDC($hGUI) $hDC = _WinAPI_GetWindowDC(0) _WinAPI_BitBlt($hGUIDC, 0, 0, 400, 450, $hDC, 0, 0, $SRCCOPY) _WinAPI_ReleaseDC (0, $hDC) _WinAPI_ReleaseDC ($hGUI, $hGUIDC) EndFunc </syntaxhighlight> ===_WinAPI_IsWindow=== #include <WinAPI.au3> _WinAPI_IsWindow($hWnd) Funkcja sprawdza czy podany uchwyt jest uchwytem istniejącego okna. Zwraca True gdy jest, lub False gdy nie jest. '''$hWnd''' - sprawdzany uchwyt ===_WinAPI_IsWindowVisible=== #include <WinAPI.au3> _WinAPI_IsWindowVisible($hWnd) Funkcja sprawdza czy podany uchwyt jest uchwytem widocznego okna. Zwraca True gdy jest, lub False gdy nie jest. '''$hWnd''' - sprawdzany uchwyt Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $hGui = GUICreate('') MsgBox(0, 'Test 1', _WinAPI_IsWindowVisible($hGui)) GUISetState() MsgBox(0, 'Test 2', _WinAPI_IsWindowVisible($hGui)) </syntaxhighlight> ===_WinAPI_EnumWindows=== #include <WinAPI.au3> _WinAPI_EnumWindows([$fVisible = True [, $hwnd = Default]]) Funkcja zwraca listę wszystkich otwartych okien w postaci dwuwymiarowej tablicy: [0][0] - liczba okien (n) - [1][0] - uchwyt pierwszego okna [1][1] - nazwa klasy pierwszego okna ... [n][0] - uchwyt n-tego okna [n][1] - nazwa klasy n-tego okna '''$fVisible''' - określa które okna mają być uwzględnione, True - tylko widoczne, False - wszystkie '''$hwnd''' - uchwyt do okna startowego, domyślnie jest to pulpit Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $aWindows = _WinAPI_EnumWindows() For $i = 1 To $aWindows[0][0] $text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF $text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF $text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF $text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF $text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0]) MsgBox(0, "Otwarte okna: " & $i & " of " & $aWindows[0][0], $text) Next </syntaxhighlight> ===_WinAPI_EnumWindowsPopup=== #include <WinAPI.au3> _WinAPI_EnumWindowsPopup() Funkcja zwraca listę wszystkich otwartych okien typu popup w postaci dwuwymiarowej tablicy: [0][0] - liczba okien (n) - [1][0] - uchwyt pierwszego okna [1][1] - nazwa klasy pierwszego okna ... [n][0] - uchwyt n-tego okna [n][1] - nazwa klasy n-tego okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $aWindows = _WinAPI_EnumWindowsPopup() If $aWindows[0][0] = 0 Then MsgBox(0, "Otwarte okna popup: ", "Brak okien popup.") else For $i = 1 To $aWindows[0][0] $text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF $text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF $text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF $text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF $text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0]) MsgBox(0, "Otwarte okna popup: " & $i & " of " & $aWindows[0][0], $text) Next EndIf </syntaxhighlight> ===_WinAPI_EnumWindowsTop=== #include <WinAPI.au3> _WinAPI_EnumWindowsTop() Funkcja zwraca listę wszystkich otwartych okien najwyższego poziomu w postaci dwuwymiarowej tablicy: [0][0] - liczba okien (n) - [1][0] - uchwyt pierwszego okna [1][1] - nazwa klasy pierwszego okna ... [n][0] - uchwyt n-tego okna [n][1] - nazwa klasy n-tego okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $aWindows = _WinAPI_EnumWindowsTop() For $i = 1 To $aWindows[0][0] $text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF $text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF $text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF $text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF $text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0]) MsgBox(0, "Otwarte okna: " & $i & " of " & $aWindows[0][0], $text) Next </syntaxhighlight> ===_WinAPI_EnableWindow=== #include <WinAPI.au3> _WinAPI_EnableWindow($hWnd [, $fEnable = True]) Funkcja włącza i wyłącza dostęp myszy i klawiatury do określonego okna i jego kontrolek. Zwraca poprzedni stan okna: True - okno i kontrolki były dostępne False - okno i kontrolki nie były dostępne '''$hWnd''' - uchwyt do okna '''$fEnable''' - True - udostępnienie okna, False - zablokowanie dostępu Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> #include <GUIConstantsEx.au3> $hGui = GUICreate('Okno testowe', 250, 260, 700, -1, $WS_VISIBLE, $WS_EX_TOPMOST) $hButton = GUICtrlCreateButton("Przycisk", 90, 30, 70) _WinAPI_EnableWindow($hGui, False) MsgBox(0x40000, 'Test', 'W tej chwili okno testowe jest niedostępne,' & @LF & 'po naciśnięciu OK zostanie udostępnione.') _WinAPI_EnableWindow($hGui, True) MsgBox(0x40000, 'Test', 'Okno testowe jest dostępne.') </syntaxhighlight> ===_WinAPI_ClientToScreen=== #include <WinAPI.au3> _WinAPI_ClientToScreen($hWnd, ByRef $tPoint) Funkcja przelicza współrzędne obszaru roboczego okna na współrzędne ekranowe (bezwzględne). Zwraca strukturę ze współrzędnymi ekranowymi. Jeżeli wystąpi błąd makeo @error przyjmuje kod błędu. '''$hWnd''' - uchwyt do okna '''$tPoint''' - struktura '''$tagPOINT''' za współrzędnymi przestrzeni roboczej okna. W wyniku działania struktura przez referencję przyjmie dane dla współrzędnych ekranowych, czyli takie same jakie funkcja zwraca. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> ;tworzenie testowego GUI $hwnd = GUICreate("TOkno testowe", 200, 200,400,300) GUISetState() $xc = 0 $yc = 0 ;tworzenie struktury i nadanie wartości $tpoint = DllStructCreate($tagPOINT) DllStructSetData($tpoint, "X", $xc) DllStructSetData($tpoint, "Y", $yc) ;odczyt współrzędnych ekranowych _WinAPI_ClientToScreen($hwnd, $tpoint) $xs = DllStructGetData($tpoint, "X") $ys = DllStructGetData($tpoint, "Y") MsgBox(4096, "_WinAPI_ClientToScreen", "Współrzędne przestrzeni rogoczej okna:" _ & @LF & "Xc = " & $xc & @TAB & @TAB & "Yc = " & $yc & @LF & @LF & _ "Współrzędne ekranu:" & @LF & "Xs = " & $xs & @TAB & @TAB & "Ys = " & $ys & @LF) </syntaxhighlight> ===_WinAPI_ScreenToClient=== #include <WinAPI.au3> _WinAPI_ScreenToClient($hWnd, ByRef $tPoint) Funkcja przelicza współrzędne ekranowe (bezwzględne), na współrzędne obszaru roboczego okna . Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna '''$tPoint''' - struktura '''$tagPOINT''' za współrzędnymi ekranowymi. W wyniku działania struktura przez referencję przyjmie dane dla współrzędnych przestrzeni roboczej okna. Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hWnd = GUICreate("Testowe okno", 400, 200) GUISetState() Do $MousePos = MousePos($hWnd) ToolTip("Ekran:" & @LF & "Xs= " & $MousePos[0] & @LF & "Ys= " & $MousePos[1] & @LF _ & @LF & "Okno:" & @LF & "Xc= " & $MousePos[2] & @LF & "Yc= " & $MousePos[3]) Until GUIGetMsg() = $GUI_EVENT_CLOSE Func MousePos($hWnd) Local $MousePos[4], $tPoint = DllStructCreate($tagPOINT) $MousePos[0] = MouseGetPos(0) $MousePos[1] = MouseGetPos(1) DllStructSetData($tPoint, "X", $MousePos[0]) DllStructSetData($tPoint, "Y", $MousePos[1]) ;przeliczenie współrzędnych ekranowych na współrzędne okna _WinAPI_ScreenToClient($hWnd, $tPoint) $MousePos[2] = DllStructGetData($tPoint, "X") $MousePos[3] = DllStructGetData($tPoint, "Y") Return $MousePos EndFunc </syntaxhighlight> ===_WinAPI_GetClientRect=== #include <WinAPI.au3> _WinAPI_GetClientRect($hWnd) Funkcja zwraca współrzędne obszaru roboczego okna w postaci struktury $tagRECT. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna '''UWAGA:''' Zwracane wyniki są we współrzędnych obszaru roboczego więc poszczególne pola struktury zawierają: "Left" - 0 "Right" - szerokość przestrzeni roboczej okna "Top" - 0 "Bottom" - wysokość przestrzeni roboczej okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $tRect = _WinAPI_GetClientRect($hwnd) MsgBox(4096, "Obszar roboczy:", _ "Lewo..: " & DllStructGetData($tRect, "Left") & @LF & _ "Prawo.: " & DllStructGetData($tRect, "Right") & @LF & _ "Góra...: " & DllStructGetData($tRect, "Top") & @LF & _ "Dół....: " & DllStructGetData($tRect, "Bottom")) </syntaxhighlight> ===_WinAPI_GetClientHeight=== #include <WinAPI.au3> _WinAPI_GetClientHeight($hWnd) Funkcja zwraca wysokość obszaru roboczego okna. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $h = _WinAPI_GetClientHeight($hwnd) MsgBox(4096, "Obszar roboczy:", "Wysokość = " & $h) </syntaxhighlight> ===_WinAPI_GetClientWidth=== #include <WinAPI.au3> _WinAPI_GetClientWidth($hWnd) Funkcja zwraca szerokość obszaru roboczego okna. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $w = _WinAPI_GetClientWidth($hwnd) MsgBox(4096, "Obszar roboczy:", "Szerokość = " & $w) </syntaxhighlight> ===_WinAPI_GetWindowRect=== #include <WinAPI.au3> _WinAPI_GetWindowRect($hWnd) Funkcja zwraca współrzędne okna w postaci struktury $tagRECT. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna '''UWAGA:''' Zwracane wyniki są we współrzędnych ekranu. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $tRect = _WinAPI_GetWindowRect($hwnd) MsgBox(4096, "Współrzędnr okna:", _ "Lewo..: " & DllStructGetData($tRect, "Left") & @LF & _ "Prawo.: " & DllStructGetData($tRect, "Right") & @LF & _ "Góra...: " & DllStructGetData($tRect, "Top") & @LF & _ "Dół....: " & DllStructGetData($tRect, "Bottom")) </syntaxhighlight> ===_WinAPI_GetWindowPlacement=== #include <WinAPI.au3> _WinAPI_GetWindowPlacement ( $hWnd ) Funkcja zwraca w postaci struktury $tagWINDOWPLACEMENT informację o umiejscowieniu i wielkości okna na ekranie. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera, a szczegółowe informacje o błędzie można uzyskać wywołując funkcję _WinAPI_GetLastError(). '''$hWnd''' - uchwyt do okna Znaczenie pól struktury $tagWINDOWPLACEMENT: '''"length"''' - wielkość struktury w bajtach '''"flags"''' - określa flagę, która kontroluje pozycję zminimalizowanego okna i metodę, dzięki której okno zostanie przywrócone. Parametr tem może mieć jedną lub więcej z następujących wartości: $WPF_ASYNCWINDOWPLACEMENT | 4 | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- $WPF_RESTORETOMAXIMIZED | 2 | Określa, że przywrócone zostanie zmaksymalizowane okno, niezależnie od tego, czy zostało ono zmaksymalizowane zanim został zminimalizowane. | | To ustawienie jest ważne tylko przy następnym przywróceniu okna. | | Nie zmienia to zachowanie domyślnego (ustalonego przez parametr funkcji WinSetState() lub GUISetState()) . | | Flaga ta jest ważna tylko wtedy, gdy pole "showcmd" ma wartość @SW_SHOWMINIMIZED. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- $WPF_SETMINPOSITION | 1 | Określa, że współrzędne zminimalizowanego okna mogą być zmienione. Flaga ta musi być ustawiona, jeśli współrzędne okna są zmieniane w polu ptMinPosition. '''"showCmd"''' - określa aktualny stan wyświetlania okna @SW_HIDE | 0 | Ukrywa okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_MAXIMIZE | 3 | Maksymalizuje okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_MINIMIZE | 6 | Minimalizuje okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_RESTORE | 9 | Uaktywnia i wyświetla okno. W przypadku, gdy okno jest zminimalizowane lub zmaksymalizowane, system przywraca je do pierwotnego rozmiaru i położenia. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOW | 5 | Uaktywnia okno i wyświetla je w swojej obecnej wielkości i położeniu. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMAXIMIZED | 3 | Uaktywnia okno i wyświetla je jako zmaksymalizowane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMINIMIZED | 2 | Uaktywnia okno i wyświetla je jako zminimalizowane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMINNOACTIVE | 7 | Wyświetla okno jako zminimalizowane. W odróżnieniu od @SW_SHOWMINIMIZED okno nie jest uaktywniane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNA | 8 | Wyświetla okno w swojej obecnej wielkości i położeniu. W odróżnieniu od @SW_SHOW okno nie jest uaktywniane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNOACTIVATE | 4 | Wyświetla okno w swojej najnowszyej wielkości i położeniu. Wartość ta jest podobna do @SW_SHOWNORMAL, z wyjątkiem tego, że okno nie jest aktywne. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNORMAL | 1 | Uaktywnia i wyświetla okno. W przypadku, gdy okno jest zminimalizowane lub zmaksymalizowane, system przywraca je do swojego pierwotnego rozmiaru i położenia. '''"ptMinPosition"''' - Określa współrzędne lewego górnego narożnika okna, gdy okno jest zminimalizowane. Pole jest 2-elementową tablicą. '''"ptMaxPosition"''' - Określa współrzędne lewego górnego narożnika okna, gdy okno jest zmaksymalizowane. Pole jest 2-elementową tablicą. '''"rcNormalPosition"''' - Określa współrzędne domyślne narożników okna (lewy-górny, prawy-dolny). Pole jest 4-elementową tablicą. ===_WinAPI_SetWindowPlacement=== #include <WinAPI.au3> _WinAPI_SetWindowPlacement ( $hWnd, $tWindowPlacement ) Funkcja ustawia wielkość i współrzędne okna za pomocą struktury $tagWINDOWPLACEMENT. Zwraca True gdy sukces, Lub False gdy wystąpił błąd. Szczegółowe informacje o błędzie można uzyskać wywołując funkcję _WinAPI_GetLastError(). '''$hWnd''' - uchwyt do okna '''$tWindowPlacement''' - struktura z danymi okna. Znaczenie pól struktury jak dla _WinAPI_GetWindowPlacement. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Run("notepad.exe") ;uruchomienie notatnika $hWnd = WinWait("[CLASS:Notepad]") ;oczekiwanie na otwarcie okna notatnika i odczyt uchwytu do niego WinMove($hWnd, "", 256, 256, 400, 400) ;przesunięcie i zmiana rozmiarów okna Sleep(1000) WinSetState($hWnd, "", @SW_MINIMIZE) ;zminimalizowanie okna Sleep(1000) $tRET = _WinAPI_GetWindowPlacement($hWnd) ;odczyt do struktury typu $stWindowPlacement danych o umiejscowieniu okna If @error = 0 Then ;formatowanie danych zodczytanych ze struktury $tagWindowPlacement $sMsg = "Pola struktury $tagWindowPlacement:" & @CRLF & "-----------------------------------------------" & @CRLF $sMsg &= "length = " & $tRET.length & " bajty" & @CRLF $sMsg &= "flags = " & $tRET.flags & @CRLF $sMsg &= "showCmd = " & $tRET.showCmd & @CRLF & @CRLF $sMsg &= "ptMinPosition:" & @CRLF $sMsg &= @TAB & "MinX = " & $tRET.ptMinPosition(1) & @CRLF $sMsg &= @TAB & "MinY = " & $tRET.ptMinPosition(2) & @CRLF & @CRLF $sMsg &= "ptMaxPosition:" & @CRLF $sMsg &= @TAB & "MaxX = " & $tRET.ptMaxPosition(1) & @CRLF $sMsg &= @TAB & "MaxY = " & $tRET.ptMaxPosition(2) & @CRLF & @CRLF $sMsg &= "rcNormalPosition:" & @CRLF $sMsg &= @TAB & "left = " & $tRET.rcNormalPosition(1) & @CRLF $sMsg &= @TAB & "top = " & $tRET.rcNormalPosition(2) & @CRLF $sMsg &= @TAB & "right = " & $tRET.rcNormalPosition(3) & @CRLF $sMsg &= @TAB & "bottom = " & $tRET.rcNormalPosition(4) MsgBox(64, "", $sMsg) ;wprowadzenie za pomocą struktury nowych danych okna notatnika $tRET.rcNormalPosition(1) = 50 ;lewy $tRET.rcNormalPosition(2) = 120 ;górny $tRET.rcNormalPosition(3) = @DesktopWidth - 50 ;prawy $tRET.rcNormalPosition(4) = @DesktopHeight - 120 ;dolny $iRET = _WinAPI_SetWindowPlacement($hWnd, $tRET) WinSetState($hWnd, "", @SW_RESTORE) ;aktywowanie nowych ustawień okna ControlSetText($hWnd, "", "Edit1", "Pełny sukces!") ;wstawienie tekstu do notatnika Sleep(3000) WinKill($hWnd) ;zamknięcie okna notatnika Else MsgBox(16, "", "Błąd!") EndIf </syntaxhighlight> ===_WinAPI_GetWindowHeight=== #include <WinAPI.au3> _WinAPI_GetWindowHeight($hWnd) Funkcja zwraca wysokość okna. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $h = _WinAPI_GetWindowHeight($hwnd) MsgBox(4096, "Okno:", "Wysokość = " & $h) </syntaxhighlight> ===_WinAPI_GetWindowWidth=== #include <WinAPI.au3> _WinAPI_GetWindowWidth($hWnd) Funkcja zwraca szerokość okna. Jeżeli wystąpił błąd makro @error > 0. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $hwnd, $tRect $hwnd = GUICreate("") GUISetState() $h = _WinAPI_GetWindowWidth($hwnd) MsgBox(4096, "Okno:", "Szerokość = " & $h) </syntaxhighlight> ===_WinAPI_SetFont=== #include <WinAPI.au3> _WinAPI_SetFont($hWnd, $hFont [, $fRedraw = True]) Funkcja ustawia czcionkę w oknie o podanym uchwycie. Nie zwraca żadnej wartości. '''$hWnd''' - uchwyt do okna '''$hFont''' - uchwyt do czcionki '''$fRedraw''' - określa czy okno ma być odświeżona w momencie wywołania funkcji, True (domyślnie) - tak, False - nie. Przykład: <syntaxhighlight lang="autoit"> #include <GuiListBox.au3> #include <GuiButton.au3> #include <FontConstants.au3> $hGUI = GUICreate(@ScriptName, 320, 120) $hBtn1 = _GUICtrlButton_Create($hGUI, "Przycisk 1", 10, 10, 300, 34) $hBtn2 = _GUICtrlButton_Create($hGUI, "Przycisk 2", 10, 60, 300, 34) ;definiowanie czcionek $hFont1 = _WinAPI_CreateFont(30, 0, 0, 0, 400, False, False, False, $DEFAULT_CHARSET, _ $OUT_DEFAULT_PRECIS, $CLIP_DEFAULT_PRECIS, $DEFAULT_QUALITY, 0, 'Comic Sans MS') $hFont2 = _WinAPI_CreateFont(15, 0, 0, 0, 700) ;ustawienie czcionek _WinAPI_SetFont($hBtn1, $hFont1) _WinAPI_SetFont($hBtn2, $hFont2) GUISetState() Do Until GUIGetMsg() = $GUI_EVENT_CLOSE ;zwolnienie zasobów _WinAPI_DeleteObject($hFont1) _WinAPI_DeleteObject($hFont2) </syntaxhighlight> ===_WinAPI_GetLayeredWindowAttributes=== #include <WinAPI.au3> _WinAPI_GetLayeredWindowAttributes($hWnd, ByRef $i_transcolor, ByRef $Transparency [, $asColorRef = False]) Funkcja odczytuje atrybuty warstwy okna. Gdy sukces zwraca: 0 - nic nie ustawiono 1 - ustawiony kolor przezroczysty 2 - ustawiona przezroczystość okna 3 - ustawione oba parametry Jeżeli wystąpił błąd zwraca 0, a makro @error zawiera kod błędu. '''$hWnd''' - uchwyt do okna '''$i_transcolor''' - zmienna w której przez referencję funkcja zapisuje kolor przezroczysty '''$Transparency''' - zmienna w której przez referencję funkcja zapisuje stopień przezroczystości okna '''$asColorRef''' - określa format kodu koloru zwracany w $i_transcolor, True - format 0x00bbggrr, False (domyślnie) - format RGB '''UWAGA:''' Wartość 0 zwrócona przez funkcję oznacza błąd tylko wtedy, gdy jednocześnie makro @error ma wartość większą od zera. ===_WinAPI_SetLayeredWindowAttributes=== #include <WinAPI.au3> _WinAPI_SetLayeredWindowAttributes($hWnd, $i_transcolor [, $Transparency = 255 [, $dwFlags = 0x03 [, $isColorRef = False]]]) Funkcja ustawia atrybuty warstwy okna. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd (makro @error = 4 - działanie funkcji nie powiodło się, @extended - dodatkowe dane o przyczynach błędu). '''$hWnd''' - uchwyt do okna '''$i_transcolor''' - kod koloru przezroczystego w formacie RGB (domyślnie) lub 0x00bbggrr, w zależności od parametru $isColorRef (-1 lub Default - kolor domyślny) '''$Transparency''' - stopień przezroczystości okna, 0 - całkowicie przezroczyste, 255 (0xff) - całkowicie nieprzezroczyste '''$dwFlags''' - flaga określająca jakie własności należy ustawić: 1 - ustawić kolor przezroczysty, 2 - ustawić przezroczystość okna, 3 - ustawić oba parametry (domyślne) '''$isColorRef''' - określa format kodu koloru w $i_transcolor, True - format 0x00bbggrr, False (domyślnie) - format RGB Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> Local $transcolor, $alpha ;tworzenie okna demonstracyjnego, warstwowego (styl $WS_EX_LAYERED) $gui = GUICreate("Przezroczystość", 400, 400, -1, -1, -1, $WS_EX_LAYERED) GUISetBkColor(0xABCDEF) ;kolor tła GUI GUICtrlCreateLabel("To jest okno demonstracyjne", 100, 150) ;początkowa przezroczystość okna =0, domyślny kolor przezroczysty _WinAPI_SetLayeredWindowAttributes($gui, -1) GUISetState() ;tworzenie okna kontrolnego $guicontrol = GUICreate("Test WinAPI", 300, 250, 100, 100) $checkTrans = GUICtrlCreateCheckbox("Kolor tła przezroczysty", 10, 10) GUICtrlCreateLabel("Suwak przezroczystości okna", 10, 50) $slidTrans = GUICtrlCreateSlider(10, 70, 200, 30) ;suwak przezroczystości GUICtrlSetLimit($slidTrans, 255, 0) GUICtrlSetData(-1, 255) $Butt = GUICtrlCreateButton("Info", 10, 150, 40) ;przycisk informacji GUISetState() Do $extMsg = GUIGetMsg(1) $msg = $extMsg[0] Switch $extMsg[1] Case $guicontrol Select Case $msg = $GUI_EVENT_CLOSE Exit Case $msg = $checkTrans Or $msg = $slidTrans If GUICtrlRead($checkTrans) = $GUI_CHECKED Then ;tło przezroczyste (kolor 0xABCDEF) _WinAPI_SetLayeredWindowAttributes($gui, 0xABCDEF, GUICtrlRead($slidTrans)) Else ;bez przezroczystego tła _WinAPI_SetLayeredWindowAttributes($gui, -1, GUICtrlRead($slidTrans)) EndIf Case $msg = $Butt $info=_WinAPI_GetLayeredWindowAttributes($gui, $transcolor, $alpha) MsgBox(0, "Info", "Kolor przezroczysty: " & Hex($transcolor) & @LF & _ "Stopień przezroczystości: " & $alpha & @LF & _ "Kod ustawień: " & $info) EndSelect Case $gui If $msg = $GUI_EVENT_CLOSE Then Exit EndSwitch Until 0 </syntaxhighlight> ===_WinAPI_UpdateLayeredWindow=== #include <WinAPI.au3> _WinAPI_UpdateLayeredWindow($hWnd, $hDCDest, $pPTDest, $pSize, $hDCSrce, $pPTSrce, $iRGB, $pBlend, $iFlags) Funkcja aktualizacje położenie, wielkość, kształt, treść i przezroczystość okna warstwowego. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do warstwowego okna. Warstwowe okno jest tworzone przez użycie rozszerzonego stylu $WS_EX_LAYERED. '''$hDCDest''' - uchwyt do kontekstu urządzenie na ekranie. '''$pPTDest''' - wskaźnik do struktury $tagPOINT, która określa nową pozycję warstwowego okna. Wartość 0 oznacza, że pozycja okna nie zmienia się. '''$pSize''' - wskaźnik do struktury $tagSIZE, która określa nowy rozmiar warstwowego okna. Wartość 0 oznacza, że rozmiar okna nie zmienia się. '''$hDCSrce''' - uchwyt kontekstu urządzenia na powierzchni, która zawiera warstwowe okno. Uchwyt ten może być uzyskać wywołując funkcję _WinAPI_CreateCompatibleDC. '''$pPTSrce''' - wskaźnik do struktury $tagPOINT, która określa położenie warstwy w kontekście urządzenia. '''$iRGB''' - kod koloru stosowanego przy komponowaniu warstwowego okna. '''$pBlend''' - wskaźnik do struktury $tagBLENDFUNCTION, która określa wartość przezroczystości stosowanej przy komponowania warstwowego okna. '''$iFlags''' - parametr ten może być jedna z następujących wartości: $ULW_ALPHA - użyj $tblend jako funkcji mieszania $ULW_COLORKEY - użyj $iRGB jako kolor przezroczystości $ULW_OPAQUE - rysowanie nieprzezroczystego warstwowego okna Przykład (należy przygotować bitmapy tła okna): <syntaxhighlight lang="autoit"> #include<WindowsConstants.au3> #include<GDIPlus.au3> HotKeySet("{ESC}","_exit_") _GDIPlus_Startup() ;wczytanie bitmap tła okna Global $sGUI=_GDIPlus_ImageLoadFromFile('1.jpg') Global $subGUI=_GDIPlus_ImageLoadFromFile('2.jpg') $hGUI=GUICreate("", 493, 900, -1, 200, -1, $WS_EX_LAYERED) GUISetState() SetBitmap($hGUI,$sGUI,150) Sleep(2000) SetBitmap($hGUI,$subGUI,255) Sleep(1000) ;tworzenie okna potomnego $sb_GUI = GUICreate("", 400, 600, 50, 30, $WS_POPUP, BitOR($WS_EX_MDICHILD, $WS_EX_LAYERED), $hGUI) GUISetBkColor(0x666666, $sb_GUI) $listview = GUICtrlCreateListView("col1 |col2|col3 ", 10, 10, 380, 585) GUICtrlSetBkColor(-1, 0x666666) GUICtrlSetColor(-1, 0xF0F0F0) ;ustawienie koloru przezroczystego _WinAPI_SetLayeredWindowAttributes($sb_GUI, 0x666666) For $i = 0 To 100 ;tworzenie listy testowej GUICtrlCreateListViewItem("Item" & Random(1, 100, 1) & "|" & "Item" & Random(1, 100, 1) & _ "|" & "Item" & Random(1, 100, 1), $listview) Next GUISetState(@SW_SHOW, $sb_GUI) ;wyświetlenie okna potomnego While 1 Sleep(30) WEnd Func _exit_() _GDIPlus_ImageDispose($sGUI) _GDIPlus_ImageDispose($subGUI) _GDIPlus_Shutdown() Exit EndFunc ;funkcja wstawia bitmapę jako tło okna, jednocześnie można zmieniać przezroczystość okna Func SetBitmap($hGUI,$hImage,$iOpacity) Local $hScrDC,$hMemDC,$hBitmap,$hOld,$pSize,$tSize,$pSource,$tSource,$pBlend,$tBlend $hScrDC=_WinAPI_GetDC(0) $hMemDC=_WinAPI_CreateCompatibleDC($hScrDC) $hBitmap=_GDIPlus_BitmapCreateHBITMAPFromBitmap($hImage) $hOld=_WinAPI_SelectObject($hMemDC,$hBitmap) $tSize=DllStructCreate($tagSIZE) $pSize=DllStructGetPtr($tSize) DllStructSetData($tSize,"X",_GDIPlus_ImageGetWidth($hImage)) DllStructSetData($tSize,"Y",_GDIPlus_ImageGetHeight($hImage)) $tSource=DllStructCreate($tagPOINT) $pSource=DllStructGetPtr($tSource) $tBlend=DllStructCreate($tagBLENDFUNCTION) $pBlend=DllStructGetPtr($tBlend) DllStructSetData($tBlend,"Alpha",$iOpacity) DllStructSetData($tBlend,"Format", 1) _WinAPI_UpdateLayeredWindow($hGUI,$hScrDC,0,$pSize,$hMemDC,$pSource,0,$pBlend,$ULW_ALPHA) ;zwolnienie zasobów _WinAPI_ReleaseDC(0,$hScrDC) _WinAPI_SelectObject($hMemDC,$hOld) _WinAPI_DeleteObject($hBitmap) _WinAPI_DeleteDC($hMemDC) EndFunc ;SetBitmap </syntaxhighlight> ===_WinAPI_MoveWindow=== #include <WinAPI.au3> _WinAPI_MoveWindow($hWnd, $iX, $iY, $iWidth, $iHeight [, $fRepaint = True]) Funkcja zmienia położenie i rozmiar okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna. '''$iX''' i '''$iY''' - nowe współrzędne lewego górnego narożnika okna. '''$iCX''' i '''$iCY''' - nowa szerokość i wysokość okna. '''$fRepaint''' - True - okno potomne jest przerysowywane po przesunięciu lub zmianie wymiarów (wartość domyślna), False - okno nie jest przerysowane. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <Constants.au3> Run('notepad.exe') Sleep(2000) $hGui = WinWait("[CLASS:Notepad]", "", 5) $aOld = WinGetPos($hGUI) Sleep(2000) _WinAPI_MoveWindow ($hGui, 350, 200, 200, 200) ;przesuwanie okna $a = WinGetPos($hGui) For $i=0 To 300 Step 0.01 _WinAPI_MoveWindow ($hGui, $a[1]+$i, $a[1]+$i/2, $a[2], $a[3]) Next ;powiększanie okna $a = WinGetPos($hGui) For $i=0 To 500 Step 0.01 _WinAPI_MoveWindow ($hGui, $a[0], $a[1], $a[2]+$i, $a[3]+$i) Next ;zmniejszanie okna bez zmiany położenia jego środka $a = WinGetPos($hGui) For $i=0 To 350 Step 0.01 _WinAPI_MoveWindow ($hGui, $a[0]+$i, $a[1]+$i, $a[2]-2*$i, $a[3]-2*$i) Next Sleep(1000) ;przywrócenie pierwotnego położenia i rozmiarów okna _WinAPI_MoveWindow ($hGui, $aOld[0], $aOld[1], $aOld[2], $aOld[3]) </syntaxhighlight> Przykład 2 (z oknem potomnym): <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include<WindowsConstants.au3> Local $iX = 50, $iY = 100, $iCX = 300, $iCY = 240, $style = BitOR($WS_CHILD, $WS_VSCROLL) $h = GUICreate ( "Test" , 650 , 600, 300, 300 ) GUICtrlCreateButton(' TEST ', 250, 360, 120, 28) $ch=GUICreate("", $iCX, $iCY, $iX, $iY, $style, -1, $h) GUICtrlCreateButton(' TEST ', 50, 60, 100, 28) GUISetBkColor(0xff0000) GUISetState(@SW_SHOW ,$h) GUISetState(@SW_SHOW ,$ch) Sleep(1000) For $i=0 To 250 Sleep(1) $iX += 1 $iY += 0.5 _WinAPI_MoveWindow ($ch, $iX, $iY, $iCX, $iCY) Next Sleep(3000) </syntaxhighlight> ===_WinAPI_GetDesktopWindow=== #include <WinAPI.au3> _WinAPI_GetDesktopWindow() Funkcja zwraca uchwyt do okna desktopu. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $win = _WinAPI_GetDesktopWindow() MsgBox(0, "Uchwyt desktopu:", $win) </syntaxhighlight> ===_WinAPI_GetWindow=== #include <WinAPI.au3> _WinAPI_GetWindow($hWnd, $iCmd) Funkcja zwraca uchwyt do okna pozostającego w określonym związku z danym oknem. Zwraca 0 gdy wystąpił błąd lub nie istnieje okno o zdefiniowanym związku. '''$hWnd''' - uchwyt do okna '''$iCmd''' - parametr określa zależność między określonym oknem, a oknem, którego uchwyt ma być zwrócony: <Constants.au3>| | Opis --------------------------------------------------------------------------------------------------------- $GW_CHILD | 5 | aktywne okno podrzędne $GW_HWNDFIRST | 0 | najwyżej stojące okno wg kolejności nakładania Z, posiadające to samo okno nadrzędne $GW_HWNDLAST | 1 | najniżej stojące okno wg kolejności nakładania Z, posiadające to samo okno nadrzędne $GW_HWNDNEXT | 2 | okno będące bezpośrednio poniżej danego okna wg kolejności nakładania Z $GW_HWNDPREV | 3 | okno będące bezpośrednio powyżej danego okna wg kolejności nakładania Z $GW_OWNER | 4 | okno nadrzędne danego okna ===_WinAPI_GetForegroundWindow=== #include <WinAPI.au3> _WinAPI_GetForegroundWindow() Funkcja zwraca uchwyt do aktywnego okna, lub 0 gdy wystąpił błąd. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> MsgBox(0, "_WinAPI_GetForegroundWindow", _ "Uchwyt do aktywnego okna: " & _WinAPI_GetForegroundWindow()) </syntaxhighlight> ===_WinAPI_GetParent=== #include <WinAPI.au3> _WinAPI_GetParent($hWnd) Funkcja zwraca uchwyt do okna nadrzędnego, lub 0 gdy wystąpił błąd (pełne informacje o błędzie zwraca funkcja _WinAPI_GetLastError()). '''$hWnd''' - uchwyt do okna ===_WinAPI_SetParent=== #include <WinAPI.au3> _WinAPI_SetParent ( $hWndChild, $hWndParent ) Funkcja zmienia okno nadrzędne dla podanego okna potomnego. Zwraca uchwyt do poprzedniego okna nadrzędnego, lub 0 gdy wystąpił błąd (pełne informacje o błędzie zwraca funkcja _WinAPI_GetLastError()). '''$hWndChild''' - uchwyt do okna potomnego. '''$hWndParent''' - uchwyt do nowego okna nadrzędnego, jeżeli =0 to nowym oknem nadrzędnym będzie pulpit. <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> #include <WindowsConstants.au3> ;tworzenie dwóch okien GUI $hGUI1 = GUICreate("GUI 1", 400, 400, 200, 100) $hGUI2 = GUICreate("GUI 2", 400, 400, 1200, 200) ;tworzenie okna potomnego w oknie GUI 1 $hChild = GUICreate("Okno potomne", 200, 200, 50, 50, BitOR($WS_CHILD, $WS_CAPTION), -1, $hGUI1) ;wyświetlenie okien GUISetState(@SW_SHOW, $hGUI1) GUISetState(@SW_SHOW, $hChild) GUISetState(@SW_SHOW, $hGUI2) MsgBox(64,"","Okno potomne do GUI 2") _WinAPI_SetParent($hChild, $hGUI2) ;zmiana okna nadrzędnego MsgBox(64,"","Okno potomne do GUI 1") _WinAPI_SetParent($hChild, $hGUI1) ;zmiana okna nadrzędnego Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_GetAncestor=== #include <WinAPI.au3> _WinAPI_GetAncestor($hWnd [, $iFlags = 1]) Funkcja zwraca uchwyt okna nadrzędnego, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, którego przodka chcemy uzyskać, jeżeli jest to uchwyt do pulpitu to funkcja zwróci 0 '''$iFlags''' - określa jakiego okna uchwyt chcemy uzyskać: WindowsConstants.au3 | | Opis --------------------------------------------------------------------------------------- $GA_PARENT | 1 | zwraca uchwyt do rodzica obiektu przekazanego jako argument, | | jeżeli pierwszym w kolejności "rodzicem" nie jest | | okno programu lecz inny obiekt, to zwrócony zostanie | | uchwyt do tego obiektu, a nie do okna programu --------------------------------------------------------------------------------------- $GA_ROOT | 2 | zwraca uchwyt do okna obiektu przekazanego jako argument, | | poprzez przejście przez kolejnych "rodziców" (parent) | | wskazanego obiektu, aż natrafi na okno --------------------------------------------------------------------------------------- $GA_ROOTOWNER | 3 | --------------------------------------------------------------------------------------- Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <WindowsConstants.au3> $hWnd = GUICreate("TEST") $hParent = _WinAPI_GetAncestor($hWnd, $GA_PARENT) MsgBox(0, "GetAncestor dla " & $hWnd, _ 'Parent:' & @TAB & @TAB & $hParent & @CRLF & _ 'Root:' & @tab & @tab & _WinAPI_GetAncestor($hWnd, $GA_ROOT) & @CRLF & _ 'Root Owner:' & @tab & _WinAPI_GetAncestor($hWnd, $GA_ROOTOWNER)) </syntaxhighlight> ===_WinAPI_GetWindowLong=== #include <WinAPI.au3> _WinAPI_GetWindowLong($hWnd, $iIndex) Funkcja zwraca informacje o określonym oknie. Jeżeli wystąpi błąd makro @error zwraca kod błędu. '''$hWnd''' - uchwyt do okna '''$iIndex''' - rodzaj zwracanej informacji: <Constants.au3> | | Opis ------------------------------------------------------------------------------------------------ $GWL_EXSTYLE |-20 | rozszerzony styl okna $GWL_HINSTANCE | -6 | uchwyt do instancji programu $GWL_HWNDPARENT | -8 | uchwyt do okna nadrzędnego (jeśli dane okno ma rodzica) $GWL_ID |-12 | identyfikator okna potomnego $GWL_STYLE |-16 | styl okna $GWL_USERDATA |-21 | 32-bitowe dane użytkownika powiązane z oknem. Takie dane są przeznaczone | | do użycia przez program, który utworzył okno. Na początku ta wartość =0. $GWL_WNDPROC | -4 | adres procedury okna ===_WinAPI_SetWindowLong=== #include <WinAPI.au3> _WinAPI_SetWindowLong($hWnd, $iIndex, $iValue) Funkcja ustawia parametry okna o określonym uchwycie. Zwraca poprzednią wartość ustawianego parametru, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna '''$iIndex''' - rodzaj ustawianej informacji (jak dla _WinAPI_GetWindowLong) Przykłąd: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <Constants.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> $hGui = GUICreate('_WinAPI_SetWindowLong', 250, 260) $iButton = GUICtrlCreateButton('Zmiana stylu okna', 10, 10, 120, 28) $iExStyle = $WS_EX_TOOLWINDOW GUISetState() Do Switch GUIGetMsg() Case $iButton $iOldExStyle = _WinAPI_SetWindowLong($hGui, $GWL_EXSTYLE, $iExStyle) $iExStyle = $iOldExStyle GUISetState(@SW_HIDE) GUISetState(@SW_SHOW) Case $GUI_EVENT_CLOSE Exit EndSwitch Until 0 </syntaxhighlight> ===_WinAPI_GetWindowText=== #include <WinAPI.au3> _WinAPI_GetWindowText($hWnd) Funkcja zwraca tytuł z belki okna lub z kontrolki o podanym uchwycie. Jeżeli wystąpił błąd ustawiane jest makro @error. '''$hWnd''' - uchwyt do okna (kontrolki) Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $hWin = WinGetHandle("[ACTIVE]") $hGui = GUICreate('Okno testowe') $iButton = GUICtrlCreateButton('Przycisk', 10, 10) GUISetState() MsgBox(0, 'Wyniki:', _ _WinAPI_GetWindowText($hWin) &@CRLF& _ _WinAPI_GetWindowText($hGui) &@CRLF& _ _WinAPI_GetWindowText(GUICtrlGetHandle($iButton))) </syntaxhighlight> ===_WinAPI_SetWindowText=== #include <WinAPI.au3> _WinAPI_SetWindowText($hWnd, $sText) Funkcja wstawia tytuł na belce okna lub kontrolce o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna (kontrolki) '''$sText''' - wstawiany tekst tytułu okna lub kontrolki Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <GUIConstantsEx.au3> $hGui = GUICreate('GUI testowy', 350, 260) $iButton = GUICtrlCreateButton('Przycisk', 10, 10, 160, 28) $hButton = GUICtrlGetHandle(-1) GUISetState() Do Switch GUIGetMsg() Case $iButton If _WinAPI_GetWindowText($hButton) = "Przycisk" Then _WinAPI_SetWindowText($hButton, "Klawisz") Else _WinAPI_SetWindowText($hButton, "Przycisk") EndIf $txt = _WinAPI_GetWindowText($hGui) & "!" _WinAPI_SetWindowText($hGui, $txt) Case $GUI_EVENT_CLOSE Exit EndSwitch Until False </syntaxhighlight> ===_WinAPI_GetClassName=== #include <WinAPI.au3> _WinAPI_GetClassName($hWnd) Funkcja zwraca nazwę klasy, do której należy okno. Jeżeli wystąpi błąd ustawiane jest makro @error. '''$hWnd''' - uchwyt do okna Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $hDesktop = _WinAPI_GetDesktopWindow() ;uchwyt do desktopu MsgBox(0, "Klasa okna desktopu", 'ClassName = "' & _WinAPI_GetClassName($hDesktop) & '"') $hwnd = GUICreate("test") ;uchwyt do okna skryptu $iButton = GUICtrlCreateButton('TEST', 10, 10, 120, 28) MsgBox(0, "Klasa okna skryptu", 'ClassName = "' & _WinAPI_GetClassName($hwnd) & '"') </syntaxhighlight> ===_WinAPI_SetWindowPos=== #include <WinAPI.au3> _WinAPI_SetWindowPos($hWnd, $hAfter, $iX, $iY, $iCX, $iCY, $iFlags) Funkcja zmienia rozmiar, położenie i Z-kolejność okna dziecka, pop-up, lub okna najwyższego poziomu. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna. '''$hAfter''' - uchwyt do okna poprzedzającego dane okno w osi Z (znajdującego się bezpośrednio nad nim), lub jedna z poniższych wartości: Wg Constants.au3 | | Opis --------------------------------------------------------------------------------------------------------- $HWND_BOTTOM | 1 | Umieszcza okno na spodzie Z rzędu. --------------------------------------------------------------------------------------------------------- $HWND_NOTOPMOST | -2 | Umieszcza okno poniżej wszystkich okien najwyższego poziomu. Ustawienie tej | | flagi niczego nie zmienia, jeśli okno nie jest oknem najwyższego poziomu. --------------------------------------------------------------------------------------------------------- $HWND_TOP | 0 | Umieszcza okno na wierzchu Z rzędu. --------------------------------------------------------------------------------------------------------- $HWND_TOPMOST | -1 | Umieszcza okno powyżej wszystkich okien, które nie są oknami najwyższego poziomu. | | Okno utrzymuje swój stan okna najwyższego poziomu, nawet gdy jest dezaktywowane. --------------------------------------------------------------------------------------------------------- '''$iX''' i '''$iY''' - nowe współrzędne lewego górnego narożnika okna. '''$iCX''' i '''$iCY''' - nowa szerokość i wysokość okna. '''$iFlags''' - flaga: Wg Constants.au3 | Wartość| Opis ------------------------------------------------------------------------------------------------------------- $SWP_DRAWFRAME | 0x0020 | Rysuje ramkę wokół okna. ------------------------------------------------------------------------------------------------------------- $SWP_FRAMECHANGED | 0x0020 | Zmienia nowe style ramki używając funkcji _SetWindowLong. Wysyła komunikat | | WM_NCCALCSIZE do okna, nawet jeśli jego rozmiar nie zostanie zmieniony. | | Jeśli ta flaga nie jest ustawiona, komunikat WM_NCCALCSIZE jest wysyłany | | tylko podczas zmiany rozmiaru okna. ------------------------------------------------------------------------------------------------------------- $SWP_HIDEWINDOW | 0x0080 | Ukrywa okno. ------------------------------------------------------------------------------------------------------------- $SWP_NOACTIVATE | 0x0010 | Nie pozwala na aktywację okna. ------------------------------------------------------------------------------------------------------------- $SWP_NOCOPYBITS | 0x0100 | Nie kopiuje zawartości obszaru klienta. Jeśli ta flaga nie jest ustawiona, | | poprawna treść obszaru klienta jest zapisywana i kopiowana z powrotem | | do obszaru klienta po zmianie pozycji lub rozmiaru okna. ------------------------------------------------------------------------------------------------------------- $SWP_NOMOVE | 0x0002 | Zachowuje obecną pozycję (ignoruje wartości argumentów $iX i $iY). ------------------------------------------------------------------------------------------------------------- $SWP_NOOWNERZORDER | 0x0200 | Nie zmienia pozycji okna w osi Z. $SWP_NOREPOSITION | | ------------------------------------------------------------------------------------------------------------- $SWP_NOREDRAW | 0x0008 | Nie odrysowuje okna. Jeśli ta flaga jest ustawiona, okno nie jest odmalowywane. | | Kiedy ta flaga jest ustawiona, program musi jawnie odświeżyć lub odrysować | | określone części danego okna oraz okna nadrzędnego. ------------------------------------------------------------------------------------------------------------- $SWP_NOSENDCHANGING| 0x0400 | Zapobiega przechwytywaniu komunikatu WM_WINDOWPOSCHANGING przez dane okno. ------------------------------------------------------------------------------------------------------------- $SWP_NOSIZE | 0x0001 | Zachowuje obecny rozmiar okna (ignoruje argumenty $iCX i $iCY). ------------------------------------------------------------------------------------------------------------- $SWP_NOZORDER | 0x0004 | Zachowuje obecną kolejność elementów w osi Z (ignoruje argument $hAfter). ------------------------------------------------------------------------------------------------------------- $SWP_SHOWWINDOW | 0x0040 | Wyświetla dane okno. ------------------------------------------------------------------------------------------------------------- Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <Constants.au3> $hGui2 = GUICreate('Okno 1', 550, 350, 500, 200) GUISetState() Sleep(1000) $hGui1 = GUICreate('Okno 2', 350, 200, 100, 100) $iButton = GUICtrlCreateButton('TEST', 10, 10, 120, 28) GUISetState() Sleep(1000) ;przesuwanie okna (okno 1 za oknem 2) $a = WinGetPos($hGui1) For $i=0 To 300 Step 0.1 _WinAPI_SetWindowPos ($hGui1, $hGui2, $a[1]+$i, $a[1]+$i/2, $a[2], $a[3], $SWP_DRAWFRAME) Next ;powiększanie okna (okno 1 przed oknem 2) $a = WinGetPos($hGui1) For $i=0 To 500 Step 0.1 _WinAPI_SetWindowPos ($hGui1, $HWND_TOP, $a[0], $a[1], $a[2]+$i, $a[3]+$i, $SWP_DRAWFRAME) Next ;zmniejszanie okna bez zmiany położenia jego środka (okno 1 za oknem 2) $a = WinGetPos($hGui1) For $i=0 To 350 Step 0.1 _WinAPI_SetWindowPos ($hGui1, $hGui2, $a[0]+$i, $a[1]+$i, $a[2]-2*$i, $a[3]-2*$i, $SWP_DRAWFRAME) Next </syntaxhighlight> ===_WinAPI_WindowFromPoint=== #Include <WinAPI.au3> _WinAPI_WindowFromPoint (ByRef $tPoint) Funkcja zwraca uchwyt do okna znajdującego się w punkcie o podanych współrzędnych, lub 0 gdy wystąpił błąd. '''$tPoint''' - struktura $tagPOINT zawierająca współrzędne punktu '''UWAGA:''' Funkcja nie zwraca uchwytu do okien ukrytych lub wyłączonych, nawet gdy punkt znajduje się wewnątrz okna. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> HotKeySet("{ESC}", "Close") ;ESC - koniec programu $tStruct = DllStructCreate($tagPOINT) ;tworzenie struktury Do ToolTip("") ;odczyt współrzednych kursora i zapis do struktury DllStructSetData($tStruct, "x", MouseGetPos(0)) DllStructSetData($tStruct, "y", MouseGetPos(1)) ;odczyt uchwytu do okna pod kursorem $hWnd = _WinAPI_WindowFromPoint($tStruct) ToolTip($hWnd) ;wyświetlenie uchwytu do okna Sleep(100) Until 0 </syntaxhighlight> ===_WinAPI_GetFocus=== #include <WinAPI.au3> _WinAPI_GetFocus() Funkcja zwraca uchwyt do okna (kontrolki) z ustawionym focus'em, lub 0 gdy wystąpił błąd. '''UWAGA:''' '''Focus''' (z ang. skupienie) jest to jeden ze stanów elementu graficznego interfejsu użytkownika. Wszelkie zdarzenia związane z naciskaniem klawiszy przez użytkownika zostaną skierowane właśnie do tego elementu (np.kontrolki). Zazwyczaj w oknach można przenosić focus na następny element za pomocą klawisza TAB (i SHIFT-TAB). Focus jest najczęściej odpowiednio odwzorowany w wyglądzie elementu, np. przycisk dostaje dodatkowe obramowanie, w polu edycyjnym pojawia się migający kursor, itp. ===_WinAPI_SetFocus=== #include <WinAPI.au3> _WinAPI_SetFocus($hWnd) Funkcja ustawia focus dla danego okna (kontrolki). Zwraca uchwyt do okna (kontrolki), które poprzednio miało ustawiony focus, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna (kontrolki), dla której ustawiamy focus Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <GUIConstantsEx.au3> $hGui = GUICreate("Focus - okno testowe", 370, 80, -1, 300) $hInput1 = GUICtrlCreateInput("Pole 1", 12, 28, 121, 21) $hInput2 = GUICtrlCreateInput("Pole 2", 232, 28, 121, 21) $hButton1 = GUICtrlCreateButton("<", 148, 24, 27, 25) $hButton2 = GUICtrlCreateButton(">", 184, 24, 27, 25) GUISetState(@SW_SHOW) Sleep(2000) $hFocus = _WinAPI_GetFocus() ;przycisk z focusem MsgBox(0, "Focus na kontrolce:", WinGetTitle($hFocus)) While 1 Switch GUIGetMsg() Case $GUI_EVENT_CLOSE Exit Case $hButton1 _WinAPI_SetFocus(GUICtrlGetHandle($hInput1)) Case $hButton2 _WinAPI_SetFocus(GUICtrlGetHandle($hInput2)) EndSwitch WEnd </syntaxhighlight> ===_WinAPI_FlashWindow=== #include <WinAPI.au3> _WinAPI_FlashWindow ( $hWnd [, $bInvert = True] ) Funkcja powoduje pojedyncze mrugnięcie (flash) okna i przycisku na pasku zadań. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, które ma mrugnąć. Okno może być otwarte lub zminimalizowane. '''$bInvert''' - określa sposób zadziałania: True - powoduje mrugnięcie okna i przycisku na pasku zadań, jeżeli okno jest zminimalizowane mruga przycisk i zmienia barwę False - okno i przycisk nie mrugają, jeżeli okno jest zminimalizowane przycisk zmienia barwę bez uprzedniego mrugnięcia Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hWnd = GUICreate("_WinAPI_FlashWindow", 200, 200) $idBtnFlash = GUICtrlCreateButton("Mrugnięcie", 50, 85, 100, 30) GUISetState(@SW_SHOW) While 1 $iMsg = GUIGetMsg() Select Case $iMsg = $GUI_EVENT_CLOSE Exit Case $iMsg = $idBtnFlash Sleep(2000) _WinAPI_FlashWindow($hWnd) EndSelect WEnd </syntaxhighlight> ===_WinAPI_FlashWindowEx=== #include <WinAPI.au3> _WinAPI_FlashWindowEx ( $hWnd [, $iFlags = 3 [, $iCount = 3 [, $iTimeout = 0]]] ) Funkcja powoduje mrugnie (flash) okna i przycisku na pasku zadań. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd. W stosunku do _WinAPI_FlashWindow posiada większe możliwości konfigurowania. '''$hWnd''' - uchwyt do okna, które ma mrugać. Okno może być otwarte lub zminimalizowane. '''$iFlags''' - tryb działania: 0 - mruganie wyłączone, system przywraca okno do stanu pierwotnego 1 - mruganie okna 2 - mruganie przycisku na pasku zadań 4 - mruganie nieprzerwane, aż do zatrzymania 8 - mruga nieprzerwanie, aż okno wyjdzie na pierwszy plan '''$iCount''' - ilość mrugnięć okna '''$iTimeout''' - czas mrugnięcia w milisekundach, 0 - domyślny czas mrugnięcia kursora Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hWnd = GUICreate("_WinAPI_FlashWindowEx", 200, 200) $idBtnFlash = GUICtrlCreateButton("Mrugnięcia", 50, 85, 100, 30) GUISetState(@SW_SHOW) While 1 $iMsg = GUIGetMsg() Select Case $iMsg = $GUI_EVENT_CLOSE Exit Case $iMsg = $idBtnFlash Sleep(1000) _WinAPI_FlashWindowEx($hWnd, 3, 6) EndSelect WEnd </syntaxhighlight> ==Mysz i klawiatura== ===_WinAPI_GetAsyncKeyState=== #include <WinAPI.au3> _WinAPI_GetAsyncKeyState ( $iKey ) Funkcja sprawdza czy został wciśnięty klawisz o podanym kodzie. Zwraca liczbę dwu bajtową w której: - ustawiony jest najstarszy bit jeżeli dany klawisz jest wciśnięty w momencie wywołania funkcji (wartość -32767) - ustawiony jest najmłodszy bit jeżeli dany klawisz był wciśnięty po poprzednim wywołaniu funkcji _WinAPI_GetAsyncKeyState (wartość 1, na tym rezultacie nie można jednak w 100% polegać) - ma wartość 0 gdy klawisz nie był wciśnięty, lub gdy wystąpił błąd '''$iKey''' - kod klawisza ([http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx MSDN Library - Virtual-Key Codes] '''UWAGA:''' 1. Funkcja rozpoznaje stan klawiszy klawiatury i myszy. 2. Funkcja rozpoznaje tylko klawisze fizyczne, a nie funkcjonalne. Przykładowo lewy klawisz myszy to konstrukcyjnie klawisz z lewej strony urządzenie, a nie klawisz mający funkcję lewego klawisza (w systemie operacyjnym osoba leworęczna można przypisać funkcję lewego klawisza do fizycznego klawisza prawego). Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $iKey = 0x1 ;lewy przycisk myszy Sleep(2000) MsgBox(0, "", _WinAPI_GetAsyncKeyState($iKey)) ;wyświetli -32767 gdy lewy przycisk myszy był wciśnięty w momencie ;wywołania funkcji, 1 gdy wciśniemy na krótko klawisz przed wywołaniem ;funkcji, 0 gdy w ogóle nie wciśniemy lewego klawisza myszy </syntaxhighlight> ===_WinAPI_Mouse_Event=== #include <WinAPI.au3> _WinAPI_Mouse_Event($iFlags [, $iX = 0 [, $iY = 0 [, $iData = 0 [, $iExtraInfo = 0]]]]) Funkcja symuluje ruchy myszy, wciskanie jej przycisków i obracanie kółkiem. Nie zwraca żadnej wartości. '''$iFlags''' - flaga określająca rodzaj symulowanej akcji myszy, może być każdą rozsądną kombinacją następujących wartości: wg Constants.au3 | | opis ------------------------------------------------------------------------------------ $MOUSEEVENTF_ABSOLUTE | 0x8000 | $iX i $iY są współrzędnymi absolutnymi kursora | | w przeciwnym razie są przesunięciami w danej osi ------------------------------------------------------------------------------------ $MOUSEEVENTF_MOVE | 0x0001 | przesunięcie myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_LEFTDOWN | 0x0002 | wciśnięty lewy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_LEFTUP | 0x0004 | zwolniony lewy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_RIGHTDOWN | 0x0008 | wciśnięty prawy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_RIGHTUP | 0x0010 | zwolniony prawy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_MIDDLEDOWN | 0x0020 | wciśnięty środkowy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_MIDDLEUP | 0x0040 | zwolniony środkowy klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_WHEEL | 0x0800 | obrócone kółko myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_XDOWN | 0x0080 | wciśnięty X klawisz myszy ------------------------------------------------------------------------------------ $MOUSEEVENTF_XUP | 0x0100 | zwolniony X klawisz myszy '''$iX''' i '''$iY''' - nowe współrzędne absolutne kursora myszy ($MOUSEEVENTF_ABSOLUTE) lub przesunięcie kursora w odpowiedniej osi '''$iData''' - jeżeli ustawione $MOUSEEVENTF_WHEEL to jest to wielkość obrotu kółka myszy, wartość dodatnia - obrót do przodu, wartość ujemna - obrót do tyłu, jednostkowy obrót kółka to 120, jeżeli $MOUSEEVENTF_WHEEL nie jest ustawione to powinno być $iData = 0 '''$iExtraInfo''' - 32 bitowa wartość związana z myszą '''UWAGA:''' Współrzędne $iX i$iY odnoszą się do wirtualnego ekranu o wymiarach 65535x65535. Aby przeliczyć rzeczywiste współrzędne na wirtualne należy przyjąć: $iX=$x*65535/@DesktopWidth i $y=$y*65535/@DesktopHeight (gdzie $x i $y to rzeczywiste współrzędne ekranowe). Ta sama zasada dotyczy przesunięć przy nie ustawionym $MOUSEEVENTF_ABSOLUTE. Przykład: <syntaxhighlight lang="autoit"> #include <Constants.au3> #include <WinAPI.au3> Local $x = 500, $y = 400 ;przeliczenie współrzędnych na wirtualny ekran $iX = $x * 65535 / @DesktopWidth $iY = $y * 65535 / @DesktopHeight ;przesunięcie myszy _WinAPI_Mouse_Event(BitOR($MOUSEEVENTF_ABSOLUTE, $MOUSEEVENTF_MOVE), $iX, $iY) _WinAPI_Mouse_Event($MOUSEEVENTF_RIGHTDOWN) ;wciśnięcie prawego przycisku _WinAPI_Mouse_Event($MOUSEEVENTF_RIGHTUP) ;zwolnienie prawego przycisku </syntaxhighlight> ===_WinAPI_GetMousePos=== #include <WinAPI.au3> _WinAPI_GetMousePos([$fToClient = False [, $hWnd = 0]]) Funkcja zwraca bieżącą pozycję kursora myszy w postaci struktury $tagPOINT. Jeżeli wystąpił błąd ustawiane jest makro @error. '''$fToClient''' - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna '''$hWnd''' - uchwyt do okna, tylko dla $fToClient = True Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $hWnd = GUICreate("Okno testowe") GUISetState() $tPoint1 = _WinAPI_GetMousePos() $tPoint2 = _WinAPI_GetMousePos(True, $hWnd) MsgBox(0, "Położenie kursora myszy", _ "We współrzędnych absolutnych:" & @LF & _ "X = " & DllStructGetData($tPoint1, "X") & @LF & _ "y = " & DllStructGetData($tPoint1, "Y") & @LF & @LF & _ "We współrzędnych okna:" & @lf & _ "x = " & DllStructGetData($tPoint2, "X") & @lf & _ "y = " & DllStructGetData($tPoint2, "Y")) </syntaxhighlight> ===_WinAPI_GetMousePosX=== #Include <WinAPI.au3> _WinAPI_GetMousePosX ([$fToClient = False [, $hWnd = 0]]) Funkcja zwraca współrzędną poziomą kursora myszy. Jeżeli wystąpił błąd ustawiane jest makro @error. '''$fToClient''' - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna '''$hWnd''' - uchwyt do okna, tylko dla $fToClient = True ===_WinAPI_GetMousePosY=== #Include <WinAPI.au3> _WinAPI_GetMousePosY ([$fToClient = False [, $hWnd = 0]]) Funkcja zwraca współrzędną poziomą kursora myszy. Jeżeli wystąpił błąd ustawiane jest makro @error. '''$fToClient''' - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna '''$hWnd''' - uchwyt do okna, tylko dla $fToClient = True Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $hWnd = GUICreate("Okno testowe") GUISetState() $x1 = _WinAPI_GetMousePosX() $x2 = _WinAPI_GetMousePosX(True, $hWnd) $y1 = _WinAPI_GetMousePosY() $y2 = _WinAPI_GetMousePosY(True, $hWnd) MsgBox(0, "Położenie kursora myszy", _ "We współrzędnych absolutnych:" & @LF & _ "X = " & $x1 & @LF & _ "y = " & $y1 & @LF & @LF & _ "We współrzędnych okna:" & @lf & _ "x = " & $x2 & @lf & _ "y = " & $y2) </syntaxhighlight> ===_WinAPI_EnableWindow=== #include <WinAPI.au3> _WinAPI_EnableWindow ( $hWnd [, $bEnable = True] ) Funkcja blokuje, lub odblokowuje dostęp myszki i klawiatury do określonego okna lub kontrolki. Zwraca True gdy okno (kontrolka) było poprzednio zablokowane, lub Felse gdy było odblokowane. ''$hWnd''' - uchwyt do okna lub kontrolki '''$bEnable''' - rodzaj operacji, True - odblokowanie, False - blokowanie Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("_WinAPI_EnableWindow", 400, 300) $hLab = GUICtrlCreateLabel("", 70, 80,220,70) GUISetState() _WinAPI_EnableWindow ( $hGUI, False) ;zablokowanie dostępu do okna GUICtrlSetData($hLab,"Kursor zablokowany na 5 sekund") Sleep(5000) _WinAPI_EnableWindow ( $hGUI, True) ;odblokowanie dostępu do okna GUICtrlSetData($hLab,"Kursor odblokowany") Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ===_WinAPI_SetCapture=== #include <WinAPI.au3> _WinAPI_SetCapture($hWnd) Funkcja przechwytuje kursor myszki w danym oknie (kursor jest nieaktywny, ikona klepsydry). Zwraca uchwyt do okna, w którym poprzednio był przechwycony kursor, lub 0 gdy wystąpił błąd. '''$hWnd''' - uchwyt do okna, w którym zostanie przechwycony kursor ===_WinAPI_ReleaseCapture=== #include <WinAPI.au3> _WinAPI_ReleaseCapture() Funkcja zwalnia przechwytywanie kursora myszki. Zwraca True gdy sukces, lub False gdy wystąpił błąd. Przykład: <syntaxhighlight lang="autoit"> #include <GUIConstantsEx.au3> #include <WinAPI.au3> $hGUI = GUICreate("_WinAPI_SetCapture", 400, 300) $hLab = GUICtrlCreateLabel("KURSOR ZABLOKOWANY - Naciśnij ESC", 70, 80,220,70) GUISetState() Do _WinAPI_SetCapture($hGUI) ;przechwycenie kursora Until GUIGetMsg() = $GUI_EVENT_CLOSE _WinAPI_ReleaseCapture() ;zwolnienie kursora GUICtrlSetData($hLab,"KURSOR ODBLOKOWANY") Do Until GUIGetMsg() = $GUI_EVENT_CLOSE </syntaxhighlight> ==Pliki i programy== ===_WinAPI_CreateFile=== #include <WinAPI.au3> _WinAPI_CreateFile($sFileName, $iCreation [, $iAccess = 4 [, $iShare = 0 [, $iAttributes = 0 [, $pSecurity = 0]]]]) Funkcja tworzy lub otwiera plik o podanej nazwie. Zwraca otwarty uchwyt pliku, lub 0 gdy wystąpił błąd. '''$sFileName''' - nazwa pliku do utworzenia lub otwarcia '''$iCreation''' - działania odnoszące się do plików, które istnieją lub nie istnieją: 0 - tworzy nowy plik, funkcja nie działa, jeśli plik istnieje 1 - tworzy nowy plik, jeśli plik istnieje, to zostanie nadpisany 2 - otwiera plik, funkcja nie działa, jeśli plik nie istnieje 3 - otwiera plik, jeśli plik nie istnieje, funkcja tworzy plik 4 - otwiera plik i czyści go do rozmiaru 0 bajtów, funkcja nie działa, jeśli plik nie istnieje '''$iAccess''' - dostęp do obiektu: 1 - wykonanie 2 - odczytanie 4 - zapisanie '''$iShare''' - trybu udostępniania obiektu: 1 - usuwanie 2 - czytanie 4 - zapisanie '''$iAttributes''' - atrybuty pliku: 1 - plik archiwalny 2 - Plik ukryty 4 - plik tylko do odczytu 8 - jest częścią lub jest wykorzystywany wyłącznie przez system operacyjny '''$pSecurity''' - wskaźnik do struktury $tagSECURITY_ATTRIBUTES, która ustala, czy zwrócony uchwyt może być dziedziczony przez procesy potomne, jeśli $pSecurity = 0, uchwyt nie może być dziedziczony. ===_WinAPI_ReadFile=== #include <WinAPI.au3> _WinAPI_ReadFile($hFile, $pBuffer, $iToRead, ByRef $iRead [, $pOverlapped = 0]) Funkcja odczytuje dane z pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$sFileName''' - nazwa pliku do utworzenia lub otwarcia '''$pBuffer''' - wskaźnik do bufora do którego będą wczytywane dane '''$iToRead''' - maksymalna liczba bajtów do odczytu '''$iRead''' - liczba odczytanych bajtów '''$pOverlapped''' - wskaźnik do $ tagOVERLAPPED ===_WinAPI_WriteFile=== #include <WinAPI.au3> _WinAPI_WriteFile($hFile, $pBuffer, $iToWrite, ByRef $iWritten [, $pOverlapped = 0]) Funkcja zapisuje w pliku, w położeniu określonym przez wskaźnik. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hFile''' - uchwyt do pliku '''$pBuffer''' - wskaźnik do bufora zawierającego dane do zapisu '''$iToWrite''' - liczba bajtów do zapisu '''$iWritten''' - liczba zapisanych bajtów '''$pOverlapped''' - wskaźnik do $ tagOVERLAPPED ===_WinAPI_SetFilePointer=== #include <WinAPI.au3> _WinAPI_SetFilePointer($hFile, $iPos [, $iMethod = 0]) Funkcja przesuwa wskaźnik pliku o podaną ilość pozycji. Zwraca nowe położenie wskaźnika. Jeżeli wystąpił błąd makro @error <> 0. Wskaźnik pliku to pozycja, od której rozpoczyna się zapis lub odczyt danych w pliku. '''$hFile''' - uchwyt do pliku '''$iPos''' - ilość bajtów, o które zostanie przesunięty wskaźnik pliku, wartość dodatnia oznacza przesunięcie w kierunku końca pliku, ujemna w kierunku początku (maksymalna wartość 2^32) '''$iMethod''' - początkowa pozycja wskaźnika, może to być jedna z następujących wartości: 0 - początek pliku (domyślnie) 1 - aktualne położenie wskaźnika 2 - koniec pliku '''UWAGA:''' Funkcja może być użyta do odczytu aktualnego położenia wskaźnika. W takim przypadku należy podać $iPos = 0 i $iMethod = 1. ===_WinAPI_SetEndOfFile=== #include <WinAPI.au3> _WinAPI_SetEndOfFile($hFile) Funkcja ustawia fizyczny rozmiar podanego pliku w bieżącej pozycji wskaźnika pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd (makro @extended zawiera kod błędu, taki jak zwracany przez _WinAPI_GetLastError). '''$hFile''' - uchwyt do pliku '''UWAGA:''' Funkcja ta może być użyta do zmniejszenia lub zwiększenia plik, a więc do ustawienia jego rozmiaru. Jeśli plik jest zwiększany zawartość pomiędzy starym i nowym końcem pliku nie jest zdefiniowana. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $nBytes, $sFile = 'test.txt' $sTxt1 = 'abcdefghijklmnopqrstuvwxyz' & @LF & '1234567890' $len1 = StringLen($sTxt1) $tBuffer = DllStructCreate("char[" & $len1 & "]") DllStructSetData($tBuffer, 1, $sTxt1) ;tworzenie struktury z danymi ;tworzenie pliku tekstowego $hFile = _WinAPI_CreateFile($sFile, 1) ;utworzenie pliku _WinAPI_WriteFile($hFile, DllStructGetPtr($tBuffer), $len1, $nBytes) _WinAPI_CloseHandle($hFile) ;zamknięcie pliku MsgBox(0,"Test 1", FileRead($sFile)) ;odczyt 6 znaków z pliku, poczynając od poz. 3 $tBuffer = DllStructCreate("char[6]") $hFile = _WinAPI_CreateFile($sFile, 2, 2) ;otwarcie pliku do odczytu _WinAPI_SetFilePointer($hFile, 3) ;wskaźnik na poz. 3 _WinAPI_ReadFile($hFile, DllStructGetPtr($tBuffer), 6, $nBytes) ;odczyt 6 bajtów _WinAPI_CloseHandle($hFile) MsgBox(0,"Test 2", DllStructGetData($tBuffer, 1)) ;wstawienie do pliku nowych danych 6 znaków od poz. 30 $sTxt2 = "#####" $len2 = StringLen($sTxt2) $tBuffer = DllStructCreate("char[" & $len2 & "]") DllStructSetData($tBuffer, 1, $sTxt2) $hFile = _WinAPI_CreateFile($sFile, 2, 4) _WinAPI_SetFilePointer($hFile, 28) _WinAPI_WriteFile($hFile, DllStructGetPtr($tBuffer), $len2, $nBytes) _WinAPI_CloseHandle($hFile) MsgBox(0,"Test 3", FileRead($sFile)) ;skrócenie pliku na poz. 29 $hFile = _WinAPI_CreateFile($sFile, 2, 4) _WinAPI_SetFilePointer($hFile, 29) ;wskaźnik na poz. 29 _WinAPI_SetEndOfFile($hFile) ;ustawienie końca pliku _WinAPI_CloseHandle($hFile) MsgBox(0,"Test 4", FileRead($sFile)) </syntaxhighlight> ===_WinAPI_GetFileSizeEx=== #include <WinAPI.au3> _WinAPI_GetFileSizeEx($hFile) Funkcja zwraca wielkość pliku. Jeżeli wystąpi błąd ustawiane jest makro @error. '''$hFile''' - uchwyt do pliku ===_WinAPI_GetOpenFileName=== #include <WinAPI.au3> _WinAPI_GetOpenFileName ( [$sTitle = "" [, $sFilter = "All files ( *.* ) " [, $sInitalDir = "." [, $sDefaultFile = "" [, $sDefaultExt = "" [, $iFilterIndex = 1 [, $iFlags = 0 [, $iFlagsEx = 0 [, $hwndOwner = 0]]]]]]]]] ) Funkcja wywołuje systemowy selektor do otwarcia plików. Zwraca jednowymiarową tablicę z danymi wybranych plików. Jeżeli wystąpi błąd (np. nie wybrano żadnego pliku), zwracana jest jednoelementowa tablica zawierająca wartość 0. Zawartość zwracanej tablicy: $Tablica[0] - liczba łańcuchów tekstowych, jest równa ilości wybranych plików + 1 = n $Tablica[1] - ścieżka dostępu do wybranego pliku (plików) $Tablica[2] - nazwa wybranego pliku ... $Tablica[n] - nazwa wybranego pliku '''$sTitle''' - nazwa okna selektora '''$sFilter''' - zestaw filtrów określający jakie pliki będą wyświetlane. Każdy składa się z dwóch elementów. Pierwszym elementem to jego opis, który będzie wyświetlany w oknie selektora, np.: "Pliki tekstowe". Drugi element filtru opisuje maskę ​​pliku, np.: "*.txt". Aby opisać zestaw masek w jednym filtrze, należy rozdzielić je znakiem średnika (;), np.: "(*.TXT;*.DOC;*.BAK)". Maska może być kombinacją zwykłych znaków i symboli wieloznacznych (* - dowolna ilość dowolnych znaków, ? - jeden dowolny znak), np.: "a*.???" oznacza dowolną nazwę zaczynająca się na a, i dowolne 3-literowe rozszerzenie nazwy. Nie należy używać spacji w masce. Filtry można łączyć w zestawy rozdzielając poszczególne składniki znakiem pionowej kreski (|). Pełny zestaw filtrów może wyglądać np. tak: '''"Pliki Graficzne (*.bmp;*.jpg;*.gif) | Pliki tekstowe (*.txt) | Pliki audio (*.MP3;*.Wav;*.WMA)"''' '''$sInitalDir''' - początkowy folder, kropka (".") oznacza folder bieżący uruchomionego skryptu (wartość domyślna). '''$sDefaultFile''' - wyjściowa nazwa pliku, która będzie wyświetlona w polu "Nazwa pliku:", domyślnie jest string pusty czyli brak nazwy. '''$sDefaultExt''' - wyjściowe rozszerzenie nazwy pliku, domyślnie jest string pusty czyli brak wyjściowego rozszerzenia. '''$iFilterIndex''' - numer filtru, który będzie aktywny po wywołaniu selektora '''$iFlags''' - flaga, pełny opis w dokumentacji AutoIt'a, jak dla struktury $tagOPENFILENAME, np.: $OFN_ALLOWMULTISELECT = 0x80000 - możliwość wybrania większej ilości plików, $OFN_EXPLORER = 0x200 - selektor w nowym stylu. '''$iFlagsEx''' - flaga rozszerzona, pełny opis w dokumentacji AutoIt'a, jak dla struktury $tagOPENFILENAME. '''$hwndOwner''' - uchwyt do okna nadrzędnego Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $aFile = _WinAPI_GetOpenFileName( "Test selektora plików", _ "Pliki grafiki(*.jpg;*.bmp;*.gif) | Skrypt(*.au3)", _ "", "", "", 1, BitOR($OFN_ALLOWMULTISELECT, $OFN_EXPLORER)) $iFile = (UBound($aFile)>1 ? $aFile[0]-1 : 0) $txt = "Ilość wybranych plików: " & $iFile If $iFile Then $txt &= @LF & "Ścieżka do plików: " & $aFile[1] For $i = 1 To $iFile $txt &= @LF & "Nazwa pliku " & $i & ": "& $aFile[$i + 1] Next EndIf MsgBox(0, "Wybrane pliki", $txt) </syntaxhighlight> ===_WinAPI_GetSaveFileName=== #include <WinAPI.au3> _WinAPI_GetSaveFileName ( [$sTitle = "" [, $sFilter = "All files ( *.* ) " [, $sInitalDir = "." [, $sDefaultFile = "" [, $sDefaultExt = "" [, $iFilterIndex = 1 [, $iFlags = 0 [, $iFlagsEx = 0 [, $hwndOwner = 0]]]]]]]]] ) Funkcja wywołuje systemowy selektor do zapisywania pliku. Zwraca jednowymiarową tablicę z danymi wybranego pliku. Jeżeli wystąpi błąd (np. nie wybrano żadnego pliku), zwracana jest jednoelementowa tablica zawierająca wartość 0. Zawartość zwracanej tablicy: $Tablica[0] - liczba łańcuchów tekstowych, 2 jeśli wybrano plik $Tablica[1] - ścieżka dostępu do wybranego pliku $Tablica[2] - nazwa wybranego pliku Wszystkie parametry jak dla '''_WinAPI_GetOpenFileName'''. ===_WinAPI_FlushFileBuffers=== #include <WinAPI.au3> _WinAPI_FlushFileBuffers($hFile) Funkcja powoduje zapisanie buforowanych danych do pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hFile''' - uchwyt do pliku ===_WinAPI_FindExecutable=== #include <WinAPI.au3> _WinAPI_FindExecutable($sFileName [, $sDirectory = ""]) Funkcja zwraca ścieżkę do programu (pliku wykonywalnego) skojarzonego z określonym plikiem, lub pusty string gdy wystąpił błąd (w @error ustawiony jest kod błędu). '''$sFileName''' - pełna ścieżka do istniejącego pliku '''$sDirectory''' - ścieżka do domyślnego katalogu Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $sPath = FileOpenDialog("Wybierz plik", @mydocumentsdir, "Wszystkie (*.*)", 1 + 2) If Not @error Then MsgBox(0, "Aplikacja skojarzone z plikiem", "Plik: " & @LF & $sPath & @LF & @LF & _ "Skojarzona aplikacja: " & @lf & _WinAPI_FindExecutable($sPath)) EndIf </syntaxhighlight> ===_WinAPI_GetModuleHandle=== #include <WinAPI.au3> _WinAPI_GetModuleHandle ( $sModuleName ) Funkcja zwraca uchwyt dla określonego modułu. Moduł musi być ładowany przez proces wywołujący. Gdy wystąpił błąd zwracane jest 0. '''$sModuleName''' - nazwa załadowanego modułu (*.dll lub *.exe). Jeżeli pominiemy rozszerzenie to domyślnie zostanie przyjęte jako .dll. Jeżeli moduł nie posiada rozszerzenia, to nazwę należy zakończyć kropką (np. moj_modul.). Wartość NULL zamiast nazwy oznacza, że zostanie zwrócony uchwyt do własnego procesu (skryptu). ==Powiadomienia i komunikaty== ===_WinAPI_MessageBeep=== #include <WinAPI.au3> _WinAPI_MessageBeep([$iType = 1]) Funkcja odtwarza określony dźwięk systemowy. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$iType''' - kod dźwięku 0 - normalny sygnał 1 - OK 2 - błąd 3 - pytanie 4 - wykrzyknik 5 - gwiazdka Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> MsgBox(0,"Test dźwiękowy", "0 - Normalny dźwięk") _WinAPI_MessageBeep(0) MsgBox(0,"Test dźwiękowy", "1 - OK") _WinAPI_MessageBeep(1) MsgBox(0,"Test dźwiękowy", "2 - błąd") _WinAPI_MessageBeep(2) MsgBox(0,"Test dźwiękowy", "3 - pytanie") _WinAPI_MessageBeep(3) MsgBox(0,"Test dźwiękowy", "4 - wykrzyknik") _WinAPI_MessageBeep(4) MsgBox(0,"Test dźwiękowy", "5 - gwiazdka") _WinAPI_MessageBeep(5) </syntaxhighlight> ===_WinAPI_FatalAppExit=== #include <WinAPI.au3> _WinAPI_FatalAppExit ( $sMessage ) Funkcja wyświetla okno komunikatu i kończy działanie skryptu. Nie zwraca żadnej wartości. '''UWAGA:''' Używać _WinAPI_FatalAppExit tylko wtedy, gdy nie ma możliwości zakończenia skryptu w inny sposób. Funkcja może nie zwolnić całej pamięci używanej przez skrypt oraz nie zamknąć wszystkich używanych przez niego plików. Może to spowodować ogólną awarię systemu. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> _WinAPI_FatalAppExit ("To już konic!") MsgBox(0, "???", "To i tak się nie wyświetli!") </syntaxhighlight> ===_WinAPI_ShowError=== #include <WinAPI.au3> _WinAPI_ShowError($sText [, $fExit = True]) Funkcja wyświetla okienko powiadomienia o błędzie i generuje stosowny sygnał dźwiękowy. Nie zwraca żadnej wartości. '''$sText''' - treść powiadomienia '''$fExit''' - określa czy działanie skryptu ma być przerwane po zamknięciu okienka, True - tak, False - nie Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> _WinAPI_ShowError('Wystąpił przerażający błąd!', False) MsgBox(4096, 'Bardzo ważna informacja!', 'Mimo wszystko próbujmy działąć dalej.') _WinAPI_ShowError('Błąd jeszcze straszniejszy!') MsgBox(4096, 'Nie ma co pisać, i tak się nie wyświetli', '') </syntaxhighlight> ===_WinAPI_ShowMsg=== #include <WinAPI.au3> _WinAPI_ShowMsg($sText) Funkcja wyświetla okienko informacyjne i generuje stosowny sygnał dźwiękowy. Nie zwraca żadnej wartości. '''$sText''' - treść powiadomienia Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> _WinAPI_ShowMsg('To jest bardzo ważna informacja!') </syntaxhighlight> ===_WinAPI_MsgBox=== #include <WinAPI.au3> _WinAPI_MsgBox($iFlags, $sTitle, $sText) Funkcja wyświetla okienko komunikatu. Nie zwraca żadnej wartości. '''$iFlags''' - flaga (jak dla MsgBox) '''$sTitle''' - tekst na belce '''$sText''' - tekst wewnątrz okienka '''UWAGA:''' Funkcja jest bardzo podobna do '''MsgBox'''. Różnicą jest to, że nie można ustalić czasu, po którym okno automatycznie się zamknie. Ponieważ funkcja nie zwraca żadnej wartości, używanie flagi o większej ilości przycisków jest pozbawione sensu (nie można rozpoznać, który przycisk został użyty). W odróżnieniu od '''MsgBox''', '''_WinAPI_MsgBox''' powoduje automatyczne odblokowanie klawiatury i myszy, co ilustruje poniższy przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> BlockInput(1) _WinAPI_MsgBox(64, '_WinAPI_MsgBox', 'Automatyczne odblokowanie') BlockInput(1) MsgBox(64, 'MsgBox', 'Odblokowanie po 3 sek.',3) BlockInput(0) </syntaxhighlight> ===_WinAPI_GetLastError=== #include <WinAPI.au3> _WinAPI_GetLastError ( ) Funkcja zwraca kod ostatniego błędu powstałego w aktualnym wątku. ===_WinAPI_GetLastErrorMessage=== #include <WinAPI.au3> _WinAPI_GetLastErrorMessage ( ) Funkcja zwraca komunikat ostatniego błędu powstałego w aktualnym wątku. ===_WinAPI_SetLastError=== #include <WinAPI.au3> _WinAPI_SetLastError ( $iErrorCode ) Funkcja ustawia kod ostatniego błędu powstałego w aktualnym wątku. '''$iErrorCode''' - kod błędu Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> FileOpen ("ble ble ble") ;próba otwarcia nieistniejącego pliku celem wywołania błędu systemowego MsgBox(64, "Błąd:", _WinAPI_GetLastError() &" - " & _WinAPI_GetLastErrorMessage()) _WinAPI_SetLastError(66) ;"ręczne" ustawienie kodu błędu MsgBox(64, "Błąd:", _WinAPI_GetLastError() &" - " & _WinAPI_GetLastErrorMessage()) </syntaxhighlight> ===_WinAPI_PostMessage=== #include <WinAPI.au3> _WinAPI_PostMessage ( $hWnd, $iMsg, $wParam, $lParam ) Funkcja wysyła komunikat do okna )kontrolki). Zwraca True gdy sukces, lub False gdy wystąpił błąd (informacje o błedzie można odczytać funkcją _WinAPI_GetLastError. '''$hWnd''' - Uchwyt okna (kontrolki) która otrzyma komunikat. Jeśli parametr wynosi 0xFFFF (HWND_BROADCAST),to komunikat zostanie wysłany do wszystkich okien najwyższego poziomu w systemie, włączając w to okna nieaktywne, niewidoczne, pokrywające się i pop-up Komunikat nie jest natomiast wysyłana do okien podrzędnych. '''$iMsg''' - wysyłany komunikat '''$wParam''' - pierwszy parametr komunikatu (zależny od rodzaju komunikatu) '''$lParam''' - drugi parametr komunikatu (zależny od rodzaju komunikatu) Komunikat | Opis | $wParam | $lParam --------------------------------------------------------------------------------------------------------------------- $WM_LBUTTONDBLCLK | Dwukrotne wciśnięcie LPM (dwuklik) | Współrzędne x i y | "" $WM_LBUTTONDOWN | Wciśnięcie i przytrzymanie LPM | Współrzędne x i y | "" $WM_LBUTTONUP | Puszczenie LPM | Współrzędne x i y | "" --------------------------------------------------------------------------------------------------------------------- $WM_MBUTTONDBLCLK | J/w dla środkowego przycisku myszy | Współrzędne x i y | "" $WM_MBUTTONDOWN | | Współrzędne x i y | "" $WM_MBUTTONUP | | Współrzędne x i y | "" --------------------------------------------------------------------------------------------------------------------- $WM_RBUTTONDBLCLK | J/w dla prawego przycisku myszy | | $WM_RBUTTONDOWN | | Współrzędne x i y | "" $WM_RBUTTONUP | | Współrzędne x i y | "" --------------------------------------------------------------------------------------------------------------------- Przykład: <syntaxhighlight lang="autoit"> #include <WindowsConstants.au3> #include <WinAPI.au3> Run("calc.exe") Sleep(1000) WinSetState("Kalkulator", "", @SW_HIDE) Sleep(200) Local $hHandle = ControlGetHandle("Kalkulator", "", "5") Local $iCoordinates = _WinAPI_MakeLong(10,10) For $i=1 To 5 _WinAPI_PostMessage($hHandle, $WM_LBUTTONDOWN, "", $iCoordinates ) _WinAPI_PostMessage($hHandle, $WM_LBUTTONUP, "", $iCoordinates ) Next Sleep(1000) WinSetState("Kalkulator", "", @SW_SHOW) </syntaxhighlight> ==System== ===_WinAPI_CloseHandle=== #include <WinAPI.au3> _WinAPI_CloseHandle($hObject) Funkcja zamyka otwarty uchwyt obiektu. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$hObject''' - uchwyt obiektu, np. okna, pliku, itp. ===_WinAPI_EnumDisplayDevices=== #include <WinAPI.au3> _WinAPI_EnumDisplayDevices ( $sDevice, $iDevNum ) Funkcja zwraca informacje na temat urządzeń wyświetlających w systemie. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera. '''$sDevice''' - nazwa urządzenia. Jeżeli pusta, funkcja zwraca informacje dla kart graficznych. '''$iDevNum''' - numer (indeks) urządzenia Informacje są zwracane w postaci jednowymiarowej tablicy: [1] - True [2] - adapter lub monitor [3] - opis adaptera lub monitora [4] - flaga statusu urządzenia (suma następujących wartości): 1 - urządzenie jest częścią pulpitu 2 - podstawowy pulpit jest na tym urządzeniu, dla systemów z jedną kartą graficzną jest zawsze ustawione, dla systemów z wieloma kartami graficznymi, może być ustawione tylko dla jednej z nich. 4 - wirtualne urządzenie dla usług zdalnego dostępu 8 - urządzenie jest kompatybilne z VGA 16 - urządzenie wymienne, nie jest głównym wyświetlaczem 32 - urządzenie posiada więcej trybów wyświetlania niż wsparcie urządzeń wyjściowych Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> Local $aDev, $i=0, $txt While 1 $aDev = _WinAPI_EnumDisplayDevices("", $i) If Not $aDev[0] Then ExitLoop $txt = "Sukces? " & $aDev[0] & @CRLF $txt &= "Urządzenie (Adapter lub monitor): " & $aDev[1] & @CRLF $txt &= "Opis (Adapter lub monitor): " & $aDev[2] & @CRLF $txt &= "Flaga statusu urządzenia: " & $aDev[3] & @CRLF If BitAND($aDev[3], 32) Then $txt &= @TAB & "- Urządzenie ma więcej trybów wyświetlania niż wsparcie urządzeń wyjściowych" & @CRLF If BitAND($aDev[3], 16) Then $txt &= @TAB & "- Urządzenie wymienne, nie jest głównym wyświetlaczem" & @CRLF If BitAND($aDev[3], 8) Then $txt &= @TAB & "- Urządzenie kompatybilne z VGA" & @CRLF If BitAND($aDev[3], 4) Then $txt &= @TAB & "- Wirtualne urządzenie dla usług zdalnego dostępu" & @CRLF If BitAND($aDev[3], 2) Then $txt &= @TAB & "- Urządzenie podstawowego pulpitu" & @CRLF If BitAND($aDev[3], 1) Then $txt &= @TAB & "- Urządzenie znajduje się w pulpicie" & @CRLF $txt &= "Ciąg identyfikatora Plug and Play: " & $aDev[4] & @CRLF MsgBox(0, "", $txt) $i += 1 WEnd </syntaxhighlight> ===_WinAPI_GlobalMemoryStatus=== #include <WinAPI.au3> _WinAPI_GlobalMemoryStatus ( ) Funkcja zwraca informacje na temat aktualnie dostępnej pamięci operacyjnej. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera. Informacje są zwracane w postaci jednowymiarowej tablicy: [0] - procent zajętej pamięci [1] - całkowity rozmiar fizycznej pamięci [2] - rozmiar wolnej pamięci fizycznej [3] - całkowity rozmiar pliku stronicowania [4] - wolny obszar pliku stronicowania [5] - całkowity rozmiar pamięci użytkownika [6] - rozmiar wolnej pamięci użytkownika Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> #include <WinAPI.au3> $aMemInfo = _WinAPI_GlobalMemoryStatus() $sMemInfo = "Procent zajętej pamięci: " & $aMemInfo[0] & "%" & @CRLF & @CRLF & _ "Całkowity rozmiar fizycznej pamięci:" & @TAB & $aMemInfo[1] & @CRLF & @CRLF & _ "Rozmiar wolnej pamięci fizyczne:" & @TAB & $aMemInfo[2] & @CRLF & @CRLF & _ "Całkowity rozmiar pliku stronicowania:" & @TAB & $aMemInfo[3] & @CRLF & @CRLF & _ "Wolny obszar pliku stronicowania:" & @TAB & $aMemInfo[4] & @CRLF & @CRLF & _ "Całkowity rozmiar pamięci użytkownika:" & @TAB & $aMemInfo[5] & @CRLF & @CRLF & _ "Rozmiar wolnej pamięci użytkownika:" & @TAB & $aMemInfo[6] MsgBox(64, "Pamięć operacyjna:", $sMemInfo) </syntaxhighlight> ===_WinAPI_ExpandEnvironmentStrings=== #include <WinAPI.au3> _WinAPI_ExpandEnvironmentStrings ( $sString ) Funkcja zwraca string odpowiadający danej zmiennej środowiskowej. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera. '''$sString''' - nazwa zmiennej systemowej Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> MsgBox(0, "String zmiennej środowiskowej", "%windir% = " & _ _WinAPI_ExpandEnvironmentStrings("%windir%")) </syntaxhighlight> ===_WinAPI_GetSystemMetrics=== #include <WinAPI.au3> _WinAPI_GetSystemMetrics($iIndex) Funkcja zwraca określoną metrykę lub ustawienie konfiguracji systemu. Jeżeli wystąpił błąd zwracane jest 0. '''$iIndex''' - indeks parametru systemu, który chcemy poznać 0 - szerokość ekranu w pikselach 1 - wysokość ekranu w pikselach 2 - szerokość pionowego paska przewijania w pikselach 3 - wysokość poziomego paska przewijania w pikselach 4 - wysokość paska tytułowego okna w pikselach 5 - szerokość obramowanie okna w pikselach 7 - grubość ramy na obwodzie okna 8 - szerokość pionowej ramki wokół obwodu okna, które ma tytuł, ale nie zmienia swojego rozmiaru 9 - wysokość thumbbox'a na pionowym pasku przewijania 10 - szerokość thumbbox'a na poziomym pasku przewijania 11 - domyślna szerokość ikony w pikselach 12 - domyślna wysokość ikony w pikselach 13 - szerokość kursora w pikselach 14 - wysokość kursora w pikselach 15 - wysokość pojedynczej linii paska menu 16 - szerokość obszaru roboczego dla okna pełnoekranowego 17 - wysokość obszaru roboczego dla okna pełnoekranowego 20 - wysokość pionowego paska przewijania 21 - szerokość poziomego paska przewijania 23 - wartość niezerowa, jeśli znacznie lewego i prawego przycisku myszy zostało zamienione, inaczej 0 28 - minimalna szerokość okna w pikselach 29 - minimalna wysokość okna w pikselach 30 - szerokość przycisku w tytule okna lub na pasku tytułowym 36 - szerokość prostokąta wokół obszaru pierwszego kliknięcia w sekwencji podwójnego kliknięcia. Drugie kliknięcie musi wystąpić w obszarze tego prostokąta, aby uznać dwa kliknięcia za podwójne kliknięcie. 37 - jak 36 lecz dla wysokości prostokąta 43 - liczba przycisków myszy, 0 gdy mysz nie zainstalowana 67 - określa jak system został uruchomiony 0 - normalnie 1 - w trybie awaryjny 2 - w trybie awaryjnym z obsługą sieci ===_WinAPI_SystemParametersInfo=== #include <WinAPI.au3> _WinAPI_SystemParametersInfo($iAction [, $iParam = 0 [, $vParam = 0 [, $iWinIni = 0]]]) Funkcja obiera albo ustawia wartość jednego z parametrów systemu. Funkcja ta może również zaktualizować profil użytkownika podczas ustawiania parametru. Zwraca True gdy sukces lub False gdy wystąpił błąd. ===_WinAPI_GetSysColor=== #include <WinAPI.au3> _WinAPI_GetSysColor($iIndex) Funkcja zwraca kod koloru elementów systemowych okien (w formacie BGR). '''$iIndex''' - kod elementu, którego kolor ma być zwrócony przez funkcję $COLOR_3DDKSHADOW | 21 | ciemny cień elementów trójwymiarowych $COLOR_3DFACE | 15 | kolor tła trójwymiarowych elementów dialogowych $COLOR_3DHILIGHT | 20 | kolor trójwymiarowego elementy ekranu (na krawędzi skierowanej do źródła światła) $COLOR_3DLIGHT | 22 | kolor trójwymiarowe elementy ekranu (na krawędzi skierowaną do źródła światła.) $COLOR_3DSHADOW | 16 | kolor cienia trójwymiarowe elementu ekranu (na krawędzi przeciwległych do źródła światła) $COLOR_ACTIVEBORDER | 10 | granice aktywnego okna $COLOR_ACTIVECAPTION | 2 | aktywny pasek tytułu $COLOR_APPWORKSPACE | 12 | obszar roboczy aplikacji (MDI). $COLOR_BTNTEXT | 18 | kolor tekstu na przycisku $COLOR_CAPTIONTEXT | 9 | kolor tekstu tytułu $COLOR_DESKTOP | 1 | kolor tła pulpitu $COLOR_GRADIENTACTIVECAPTION | 27 | kolor gradientu w prawej stronie tytułu aktywnego okna $COLOR_ACTIVECAPTION | 2 | kolor aktywnego paska tytułu $COLOR_GRADIENTINACTIVECAPTION | 28 |kolor gradientu w prawej stronie tytułu nieaktywnego okna $COLOR_INACTIVECAPTION | 3 | określa lewy kolor boczny $COLOR_GRAYTEXT | 17 | szary tekst (niedostępny) $COLOR_HIGHLIGHT | 13 | pozycja (pozycje) wybrana w kontrolce $COLOR_HIGHLIGHTTEXT | 14 | kolor tekstu elementu (elenentów) wybranego w kontrolce $COLOR_HOTLIGHT | 26 | kolor dla hiperłącza i pozycji "hot-tracked" $COLOR_INACTIVEBORDER | 11 | kolor ramki nieaktywnego okna $COLOR_INACTIVECAPTION | 3 | kolor tytuł nieaktywnego okna $COLOR_INACTIVECAPTIONTEXT | 19 | kolor tekstu w nagłówku nieaktywnego okna $COLOR_INFOBK | 24 | tło tooltip'u $COLOR_INFOTEXT | 23 | tekst na tooltip'ie $COLOR_MENU | 4 | kolor tła menu $COLOR_MENUHILIGHT | 29 | kolor pozycji menu, gdy menu jest płaskie $COLOR_MENUBAR | 30 | kolor tła menu, gdy menu jest płaskie $COLOR_MENUTEXT | 7 | kolor tekstu w menu $COLOR_SCROLLBAR | 0 | szary obszar paska przewijania $COLOR_WINDOW | 5 | kolor tła okna $COLOR_WINDOWFRAME | 6 | kolor ramy okna $COLOR_WINDOWTEXT | 8 | kolor tekstu w oknie ===_WinAPI_SetSysColors=== #include <WinAPI.au3> _WinAPI_SetSysColors($vElements, $vColors) Funkcja ustawia kolor elementów okien. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$vElements''' - kod elementu, lub tablica kodów (kody jak dla '''_WinAPI_SetGetColors''') '''$vColors''' - kod koloru, lub tablica kodów (format BRG) '''UWAGA:''' Zmiana kolorów będzie aktualna nawet po zakończeniu skryptu! Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> GUICreate("Testowy GUI", 300, 200) GUISetState() $xcol = 15 $wincol = _WinAPI_GetSysColor($xcol) ;odczyt koloru _WinAPI_SetSysColors($xcol, 0xff) ;ustawienie nowego koloru MsgBox(0, "Test", "Pierwotny kolor: " & Hex($wincol) & @LF & _ "Nowy kolor : " & Hex(_WinAPI_GetSysColor($xcol))) _WinAPI_SetSysColors($xcol, $wincol) ;odtworzenie pierwotnego koloru </syntaxhighlight> ===_WinAPI_SetDefaultPrinter=== #Include <WinAPI.au3> _WinAPI_SetDefaultPrinter ($Sprinter) Funkcja ustawia domyślną drukarkę dla bieżącego użytkownika na komputerze lokalnym. Zwraca True gdy sukces, lub False gdy wystąpił błąd. '''$Sprinter''' - domyślna nazwa drukarki. Do zdalnego wydruku nazwa ma postać: "\\server\NazwaDrukarki", dla drukarki lokalnej: "NazwaDrukarki". Jeśli tym parametrem jest "" (pusty string), to funkcja nie robi nic, o ile drukarka domyślna jest już zdefiniowana. Jednakże, jeśli domyślna drukarka nie jest dostępna, to funkcja sprawia, że ​​pierwsza na liście drukarek będzie ustawiona jako domyślna (o ile jest jakaś drukarka na liście). ==Haki== Hak (ang. hook) - mechanizm pozwalający na przechwytywanie określonych wiadomości systemowych zanim dotrą do docelowej aplikacji. Wyróżniamy dwa typy haków: - lokalne (thread hooks) – pozwalają przechwytywać wiadomości skierowane do określonego wątku, - globalne (system-wide hooks) – pozwalają przechwytywać wszystkie wiadomości danego typu wysyłane przez system. Haki można podpiąć do wielu wiadomości systemowych. Podczas wystąpienia którejś z nich (np. wciśnięcie klawisza, tworzenie okna...) Windows sprawdza czy istnieją zarejestrowane dla niej haki. Jeżeli tak – normalne operacje związane z wykonaniem zadania zostają zawieszone i kontrolę nad zdarzeniem przejmuje funkcja haka. Do niej należy przekazanie sterowania do kolejnych haków oraz poprawne przetworzenia wiadomości. W przypadku zarejestrowania więcej niż jednego haka dla danego zdarzenia zostaje budowany tzw. łańcuch haków („hook chain”). Jest to struktura typu LIFO - funkcja zarejestrowana najpóźniej otrzymuje możliwość działania jako pierwsza. Co z tego wynika? Hak zainstalowany jako ostatni może skutecznie ograniczyć wcześniejszym dostęp do informacji. System operacyjny odzyskuje kontrolę po zakończeniu działania wszystkich haków. Haki mają wiele zastosowań. Programy antywirusowe mogą instalować swoje haki aby przechwytywać otrzymywane/wysyłane e-maile i sprawdzać ich bezpieczeństwo. Keyloggery gromadzą wciśnięcia wszystkich klawiszy. Nic nie stoi na przeszkodzie, aby nasz system wzbogadcić o obsługę gestów myszki. Dodanie specyficznych skrótów klawiszowych także nie będzie problemem. Haki umożliwiają też badanie aktywności użytkownika poprzez nasłuchiwanie aktywności klawiatury i myszki. Oprócz tego mogą być przydatne przy debugowaniu aplikacji – dają bezpośredni dostęp do komunikatów systemu dla danego programu. Procedury dla haków globalnych muszą obowiązkowo znajdować się w bibliotece DLL. ===_WinAPI_SetWindowsHookEx=== #include <WinAPI.au3> _WinAPI_SetWindowsHookEx ( $iHook, $pProc, $hDll [, $iThreadId = 0] ) Funkcja zakłada hak na początku łańcucha i zwraca uchwyt do niego. Jeżeli wystąpił błąd zwracane jest 0, a informację o błędzie można odczytać za pomocą funkcji _WinAPI_GetLastError(). _SetWindowsHookEx powinniśmy wywołać tam, gdzie wykonujemy inicjalizację naszej aplikacji - np. po stworzeniu głównego okna. '''$iHook''' - Określa typ procedury haka do zainstalowania: $WH_CALLWNDPROC oraz $WH_CALLWNDPROCRET - pozwalają monitorować komunikaty przeznaczone dla konkretnej procedury okna. $WH_CALLWNDPROC przechwytuje komunikat przed jego dotarciem do procedury okna, $WH_CALLWNDPROCRET - po. $WH_CBT - nazwa pochodzi od computer-based training (CBT), czyli komputerowej edukacji, dla którego to rodzaju aplikacji przede wszystkim powstał ten hak. Pozwala przechwytywać komunikaty przed utworzeniem, zniszczeniem, minimalizacją, maksymalizacją, przeniesieniem, zmianą rozmiaru okna, przed wykonaniem polecenia systemowego, przed zdjęciem komunikatu myszy lub klawiatury z kolejki komunikatów, przed ustawieniem fokusa oraz przed synchronizacją kolejki komunikatów. Dzięki temu możemy określić, czy nasza aplikacja "pozwala" na te operacje czy też nie. Teraz już co niektórzy mogą kojarzyć - tak, wszelkiego rodzaju komputerowe testy, quizy i programy egzaminacyjne korzystają z tego, by zablokować biednym studentom dostęp do pomocy naukowych. $WH_DEBUG - ten hak wywoływany jest zawsze przed wszystkimi innymi hakami, więc można go użyć do "odpluskwiania" innych haków. $WH_FOREGROUNDIDLE - hak pozwalający nam wykonywać różne zadania w tle, gdy system wykryje, że pierwszoplanowy wątek nic w danej chwili nie robi. $WH_GETMESSAGE - pozwala przechwycić komunikat, który właśnie ma być zwrócony przez GetMessage lub PeekMessage (w przeciwieństwie do $WH_CALLWNDPROC, który przechwytuje komunikat już po wywołaniu DispatchMessage). To jest właśnie najbardziej zalecany hak do przechwytywania komunikatów związanych z myszą i klawiaturą. $WH_JOURNALPLAYBACK - ciekawy hak, który umożliwia odtworzenie "nagranych" wcześniej zdarzeń wejściowych (np. ruchu myszy). Jest to hak globalny, dotyczący wszystkich wątków w systemie. $WH_JOURNALRECORD - "nagrywa" zdarzenia do późniejszego wykorzystania przez $WH_JOURNALPLAYBACK, oczywiście to również jest hak globalny. $WH_KEYBOARD_LL - przechwytuje niskopoziomowe (low-level) zdarzenia, wywołane przez klawiaturę. $WH_KEYBOARD - przechwytuje wysokopoziomowe zdarzenia klawiatury (jest to więc wyspecjalizowany wariant haka $WH_GETMESSAGE). $WH_MOUSE_LL - przechwytuje niskopoziomowe zdarzenia myszy. $WH_MOUSE - przechwytuje wysokopoziomowe zdarzenia myszy (kolejna wyspecjalizowana wersja $WH_GETMESSAGE). $WH_MSGFILTER oraz $WH_SYSMSGFILTER - dzięki tym hakom możemy monitorować komunikaty pochodzące z menu, pasków przewijania, message box'ów oraz okien dialogowych. Możemy też wykrywać aktywację okna przy pomocy Alt+Tab lub Alt+Esc. Normalnie nie możemy tego wszystkiego zrobić, gdy wykonywana jest jakakolwiek pętla modalna np. wewnętrzna pętla message box'a). $WH_SYSMSGFILTER ma działanie globalne, zaś $WH_MSGFILTER dotyczy jedynie aplikacji, która zainstalowała hak. $WH_SHELL - został stworzony po to, byśmy w aplikacji shell'owej mogli otrzymywać istotne powiadomienia systemowe. Domyślnie jest to aktywacja aplikacji shell'owej oraz utworzenie/zniszczenie jej głównego okna. '''$pProc''' - wskaznik do procedury haka. Jeśli parametr $iThreadId wynosi zero lub określa identyfikator wątku utworzone przez inny proces, parametr $pProc musi wskazywać procedury haka w DLL. '''$hDll''' - uchwyt do biblioteki DLL zawierającej procedurę haka wskazywana przez parametr $pProc. Dla lokalnych haków należy podać wartość NULL. '''$iThreadId''' - określa identyfikator wątku, z którym procedura haka ma być związana. Jeśli parametr ten ma wartość zero, procedura haka jest związany z wszystkimi istniejącymi wątkami działającymi na tym samym pulpicie co wątek wywołujący. '''UWAGA:''' Ponieważ funkcje haków globalnych muszą znajdować się w bibliotece DLL, za pomocą sanego AutoIt'a nie można założyć haków tego rodzaju (AutoIt nie umożliwia tworzenia plików DLL). Można natomiast zakładać haki globalne z wykorzystaniem plików DLL utworzonych za pomocą innych języków programowania. ===_WinAPI_UnhookWindowsHookEx=== #include <WinAPI.au3> _WinAPI_UnhookWindowsHookEx ( $hHook ) Funkcja usuwa haka zainstalowanego w łańcuchu haków za pomocą funkcji WinAPI_SetWindowsHookEx. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd. '''$hHook''' - uchwyt do usuwanego haka ===_WinAPI_CallNextHookEx=== #include <WinAPI.au3> _WinAPI_CallNextHookEx ( $hHook, $iCode, $wParam, $lParam ) Funkcja przekazuje sterowanie do procedury następnego haka w łańcuchu haków. '''$hHook''' - ten parametr jest ignorowany '''$iCode''' - '''$wParam''' - '''$lParam''' - Przykład założenia łańcucha haków na klawiaturę: <syntaxhighlight lang="autoit"> #include <StructureConstants.au3> #include <WinAPI.au3> #include <WindowsConstants.au3> OnAutoItExitRegister("Cleanup") ;rejestracja funkcji wywoływanej przy zakończeniu skryptu Global $hHook1, $hKeyProc1, $hHook2, $hKeyProc2, $sLog $hKeyProc1 = DllCallbackRegister("_KeyProc1", "long", "int;wparam;lparam") ;rejestracja funkcji callback pierwszego haka $hHook1 = _WinAPI_SetWindowsHookEx($WH_KEYBOARD_LL, DllCallbackGetPtr($hKeyProc1), Null) ;założenie pierwszego haka $hKeyProc2 = DllCallbackRegister("_KeyProc2", "long", "int;wparam;lparam") ;rejestracja funkcji callback drugiego haka $hHook2 = _WinAPI_SetWindowsHookEx($WH_KEYBOARD_LL, DllCallbackGetPtr($hKeyProc2), Null) ;założenie drugiego haka ;pętla główna skryptu While 1 Sleep(10) WEnd #Region Definicje funkcji ;funkcja callback dla pierwszego haka Func _KeyProc1($nCode, $wParam, $lParam) Local $tKEYHOOKS $tKEYHOOKS = DllStructCreate($tagKBDLLHOOKSTRUCT, $lParam) If $nCode < 0 Then Return _WinAPI_CallNextHookEx($hHook1, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka EndIf If $wParam = $WM_KEYDOWN Then Modified_action_key1($tKEYHOOKS.vkCode) EndIf Return _WinAPI_CallNextHookEx($hHook1, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka EndFunc ;funkcja callback dla drugiego haka Func _KeyProc2($nCode, $wParam, $lParam) Local $tKEYHOOKS1 $tKEYHOOKS = DllStructCreate($tagKBDLLHOOKSTRUCT, $lParam) If $nCode < 0 Then Return _WinAPI_CallNextHookEx($hHook2, $nCode, $wParam, $lParam) ;;wywołanie kolejnego haka EndIf If $wParam = $WM_KEYDOWN Then Modified_action_key2($tKEYHOOKS.vkCode) EndIf Return _WinAPI_CallNextHookEx($hHook2, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka EndFunc ;funkcja obsługi klawiatury przez pierwszego haka Func Modified_action_key1($iKeyCode) If $iKeyCode = 27 Then Exit ;zakończenie skryptu If $iKeyCode = 49 Then Beep(262, 200) ;klawisze 1 do 8 grają gamę If $iKeyCode = 50 Then Beep(294, 200) If $iKeyCode = 51 Then Beep(330, 200) If $iKeyCode = 52 Then Beep(349, 200) If $iKeyCode = 53 Then Beep(392, 200) If $iKeyCode = 54 Then Beep(440, 200) If $iKeyCode = 55 Then Beep(494, 200) If $iKeyCode = 56 Then Beep(523, 200) If $iKeyCode = 65 Then ToolTip ("AutoIt to jest to!", 500, 200) ;klawisz A $sLog &= Chr($iKeyCode) ;log klawiatury EndFunc ;funkcja obsługi klawiatury przez drugiego haka Func Modified_action_key2($iKeyCode) If $iKeyCode = 66 Then ToolTip ("AutoIt to jest lipa!", 500, 250) ;klawisz B EndFunc ;funkcja kończąca skrypt po wciśnięciu ESC ;zwalnia zasoby i wyświetla historię użycia klawiatury (prymitywny keylogger) Func Cleanup() _WinAPI_UnhookWindowsHookEx($hHook1) ;usunięcie pierwszego haka _WinAPI_UnhookWindowsHookEx($hHook2) ;usunięcie drugiego haka DllCallbackFree($hKeyProc1) ;wyrejestrowanie funkcji callback pierwszego haka DllCallbackFree($hKeyProc2) ;wyrejestrowanie funkcji callback drugiego haka MsgBox(64, 'Log klawiatury:', $sLog) ;wyświetlenie loga EndFunc #EndRegion Koniec definicji funkcji </syntaxhighlight> ==Arytmetyka bitowa== ===_WinAPI_HiWord=== #include <WinAPI.au3> _WinAPI_HiWord($iLong) Funkcja zwraca starsze słowo (2-bajtowe) z podwójnego słowa (4-bajtowego). '''$iLong''' - podwójnego słowa (4-bajtowe) ===_WinAPI_LoWord=== #include <WinAPI.au3> _WinAPI_LoWord($iLong) Funkcja zwraca młodsze słowo (2-bajtowe) z podwójnego słowa (4-bajtowego). '''$iLong''' - podwójnego słowa (4-bajtowe) Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $iWord = 0xAAFFFF MsgBox(0, $iWord, "Starsze słowo: " & Hex(_WinAPI_HiWord($iWord)) & @CRLF & _ "Młodsze słowo: " & Hex(_WinAPI_LoWord($iWord))) </syntaxhighlight> ===_WinAPI_FloatToInt=== #include <WinAPI.au3> _WinAPI_FloatToInt($nFloat) Funkcja zamienia liczbę zmiennoprzecinkową (typ Float) na odpowiadającą jej 4-bajtową liczbę całkowitą (typ Integer). '''$nFloat''' - liczba zmiennoprzecinkowa Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $float = 10.55 $INT = _WinAPI_FloatToInt($float) $text = "Liczba zmiennoprzecinkowa " & $float & " przkonwertowano na liczbę całkowitą " & $INT & " (Hex = " & Hex($INT) & ")" MsgBox(4096, "_WinAPI_FloatToInt", $text) </syntaxhighlight> ===_WinAPI_IntToFloat=== #include <WinAPI.au3> _WinAPI_IntToFloat($iInt) Funkcja zamienia 4-bajtową liczbę całkowitą (typ Integer) na odpowiadającą jej liczbę zmiennoprzecinkową (typ Float). Jeżeli wystąpi błąd zwracany jest string "-1.#QNAN". '''$nFloat''' - 4-bajtowa liczba całkowita '''UWAGA:''' Funkcja nie zmienia typu liczby (jak np. funkcja Int()), lecz sposób interpretacji bitowego zapisu liczby w pamięci komputera. Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> MsgBox(0, "", _WinAPI_IntToFloat(1000000)) </syntaxhighlight> ===_WinAPI_MakeLong=== #include <WinAPI.au3> _WinAPI_MakeLong($iLo, $iHi) Funkcja łączy dwa 2-bajtowe słowa w 4-bajtowe podwójne słowo. '''$iLo''' - 2-bajtowe młodsze słowo '''$iHi''' - 2-bajtowe starsze słowo Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $iWord = _WinAPI_MakeLong(0xaa, 0xbb) MsgBox(4096, "_WinAPI_MakeLong", Hex($iWord)) </syntaxhighlight> ===_WinAPI_MakeQWord=== #include <WinAPI.au3> _WinAPI_MakeQWord($LoDWORD, $HiDWORD) Funkcja łączy dwa 4-bajtowe podwójne słowa w 8-bajtowe poczwórne słowo (Int64). '''$LoDWORD''' - 4-bajtowe młodsze słowo '''$HiDWORD''' - 4-bajtowe starsze słowo Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> $iWord = _WinAPI_MakeQWord(0xaa, 0xbb) MsgBox(4096, "_WinAPI_MakeQWord", Hex($iWord)) </syntaxhighlight> ===_WinAPI_MulDiv=== #include <WinAPI.au3> _WinAPI_MulDiv($iNumber, $iNumerator, $iDenominator) Funkcja mnoży dwie 32-bitowe liczby i dzieli 64-bitowy wynik przez trzecią 32-bitową liczbę. Zwraca wynik, lub -1 gdy wystąpił błąd. Jeśli wynik nie jest liczbą całkowitą, jest zaokrąglany zgodnie z ogólnymi zasadami. '''$iNumber i $iNumerator''' - dwie mnożone liczby '''$iDenominator''' - liczba przez którą dzielimy Przykład: <syntaxhighlight lang="autoit"> #include <WinAPI.au3> MsgBox(0, '_WinAPI_MulDiv', _WinAPI_MulDiv(3, 8, 6) & ' = ' & 3 * 8 / 6) </syntaxhighlight> ag95o9bm78ywk68c4t47s3rnk9uxllp 828 33072 539817 535549 2026-04-14T13:19:21Z Persino 2851 539817 Scribunto text/plain local m = {} function m.Plik(frame) if not frame then return nil end local args = frame.args if not args then mw.log("brak argumentów") return nil end local file = args[1] if not file then mw.log("brak pliku") return nil end local multipleFiles = "" if string.match(file, "%]%s*%[") then multipleFiles = "[[Kategoria:Łatki - Kilka plików]]" end if string.match(file, "^%s*%[%[") then mw.log("to jest link: "..file) return file .. "[[Kategoria:Łatki - Plik]]"..multipleFiles end if string.match(file, "^%s*%[") then mw.log("to jest link zewnętrzny: "..file) return file .. "[[Kategoria:Łatki - Plik zewnętrzny]]"..multipleFiles end local builder = {} table.insert(builder, "[[Plik:") for i, v in ipairs(args) do if i > 1 then table.insert(builder,"|") end table.insert(builder,v) end table.insert(builder, "]]") local result = table.concat(builder, "") mw.log("wynik: "..result) return result end m.PoliczLinki = function(frame) local pf = frame:getParent() local text = frame.args[1] or pf.args[1] local threshold = tonumber(frame.args["próg"] or pf.args["próg"]) or 1 if text then text = mw.text.trim(text) local _, count = mw.ustring.gsub(text, "(%[%[[^%[%]]-%]%])", "%1") if count >= threshold then local lang = mw.getContentLanguage() local number = lang:formatNum(count) local articles = lang:convertPlural(count, { "artykuł", "artykuły", "artykułów" }) return text .. "<small> ("..number.."&nbsp;"..articles..")</small>" else return text end end end m["Liczba artykułów między"] = function(frame) local pf = frame:getParent() local start = frame.args[1] or pf.args[1] if not start then return end local stop = frame.args[2] or pf.args[2] if not stop then return end local content = mw.title.getCurrentTitle():getContent() if not content then return end local startPattern = "<!--"..start.."-->" local startPosition = string.find(content, startPattern, 1, true) if not startPosition then return end startPosition = startPosition + #startPattern local stopPattern = "<!--"..stop.."-->" local stopPosition = string.find(content, stopPattern, startPosition, true) if not stopPosition then return end stopPosition = stopPosition - 1 if startPosition >= stopPosition then return end local text = string.sub(content, startPosition, stopPosition) local _, count = mw.ustring.gsub(text, "(%[%[[^%[%]]-%]%])", "%1") local _, files = mw.ustring.gsub(text, "(%[%[Plik:[^%[%]]-%]%])", "%1") count = count - files local threshold = tonumber(frame.args["próg"] or pf.args["próg"]) or 1 if count < threshold then return end local lang = mw.getContentLanguage() local number = lang:formatNum(count) local articles = lang:convertPlural(count, { frame.args[4] or pf.args[4] or "artykuł", frame.args[5] or pf.args[6] or "artykuły", frame.args[6] or pf.args[6] or "artykułów" }) local result, _ = string.gsub(frame.args[3] or pf.args[3] or "<small>($1)</small>", "$1", number.."&nbsp;"..articles) return result end m["Numerowanie w tabeli"] = function(frame) local counter = 0 local result = {} local pf = frame:getParent() local i = 1 table.insert(result, "{") while true do local object = pf:getArgument(i) if object then object = object:expand() else break end if object then table.insert(result, "|") local length = #object if length > 0 then if string.byte(object,1) == 35 then counter = counter + 1 local counterText = counter..". " local userText = length > 1 and string.sub(object, 2, length) or "" object = counterText..userText end end table.insert(result, object) i = i + 1 else break end end table.insert(result, "|}") return table.concat(result, "") end m["są interwiki"] = function(frame) local count = 0; local wiki_modul=require("Module:Wiki"); local args=frame.args; local idwiki=wiki_modul.WikidaneIdWiki{args=args} if(not idwiki)then return;end; local nazwy_modul=require("Module:Nazwy"); local pelna_nazwa_strony=nazwy_modul["PEŁNANAZWASTRONY"]{args=args,}; local identyfikator_strony=mw.wikibase.getEntityIdForTitle(pelna_nazwa_strony,idwiki); if(not identyfikator_strony)then return;end; local entity = mw.wikibase.getEntityObject(identyfikator_strony); if entity and entity.sitelinks then for k, v in pairs(entity.sitelinks) do if k ~= idwiki then count = count + 1 end end end return count > 0 and count or nil; end function m.contentMatch(frame) local args=frame and (frame.args or frame) or {}; local parametry_modul=require("Module:Parametry"); local content; local pagename;local namespace; if(not parametry_modul.CzyTak(args["dokumentacja"]))then pagename = args.pagename local nazwy_modul=require("Module:Nazwy"); namespace = nazwy_modul.Np{nazwa=(args.namespace or 0),istnieje="tak",["wynik błędu nietekstowy"]="tak",} or ""; local title = (pagename and (#pagename > 0)) and mw.title.makeTitle(namespace, pagename) or mw.title.getCurrentTitle() mw.logObject(title, "title") content = title and title:getContent() or false else local nazwy_modul=require("Module:Nazwy"); local tabela_nazw={}; namespace = args.namespace and nazwy_modul.Np{nazwa=(args.namespace or 0),istnieje="tak",["wynik błędu nietekstowy"]="tak",} or nazwy_modul["NAZWAPRZESTRZENI"](nil,tabela_nazw); pagename = (args.pagename and (#args.pagename > 0)) and args.pagename or nazwy_modul["NAZWASTRONY"](nil,tabela_nazw); local fullpagename=((namespace~="") and (namespace..":") or "")..pagename; local stronicowyparser_modul=require("Module:StronicowyParser"); content=stronicowyparser_modul.SpreparowanyWikikodStrony(fullpagename,true) or false; end; mw.logObject(pagename, "pagename") mw.logObject(namespace, "namespace") if not content then mw.log("no content") return end local i = 1 while true do local p = args[i] if not p or (#p==0) then mw.log("no pattern "..i) return end local result = mw.ustring.match(content, p) if result then mw.log("match "..result) return result end mw.log("no match "..p) i = i + 1 end end function m.contentPureTextSize(frame) local content = mw.title.getCurrentTitle():getContent() if not content then mw.log("no content") return 0 end -- wyrzucamy szablony (i szablony w szablonach) local ile; repeat content,ile = mw.ustring.gsub(content, "%{%{[^%{%}]+%}%}", ""); until ((not ile)or((ile)and(ile==0))); -- refy bez treści content = mw.ustring.gsub(content, "<ref[^<>]*%/>", ""); -- większość refów z treścią repeat content,ile = mw.ustring.gsub(content, "<ref[^<>]*>[^<>]<%/ref>", ""); until ((not ile)or((ile)and(ile==0))); -- ciąg pusty na jedną spację content = mw.ustring.gsub(content, "%s+", " "); return mw.ustring.len(content); end function m.Interwiki(frame) local qid = frame.args.id local data = mw.wikibase.getEntityObject(qid) if not data then return -- brak danych -> kategoria? end local links = {} local appendLink = function(lang, title) if not links[lang] then links[lang] = { title } else table.insert(links[lang], title) end end local knownLanguages = mw.loadData("Module:Lang/data") local extractLinks = function(data) if data.sitelinks then for k, v in pairs(data.sitelinks) do local lang = string.sub(k, 1, -5) local project = string.sub(k, -4) if (project == "wiki") and knownLanguages[lang] then appendLink(lang, v.title) end end end end extractLinks(data) if data.claims and data.claims.P460 then for _, v in ipairs(data.claims.P460) do if v.mainsnak.snaktype == "value" then local seeid = "Q"..tostring(v.mainsnak.datavalue.value["numeric-id"]) local seedata = mw.wikibase.getEntityObject(seeid) if seedata then extractLinks(seedata) end end end end local result = {} local content = mw.title.getCurrentTitle():getContent() for k, v in pairs(links) do local pattern = "%[%["..mw.ustring.gsub( k, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )..":[^%[%]|]+%]%]" local interwiki = mw.ustring.match(content, pattern) if not interwiki and not data.sitelinks[k.."wiki"] then table.insert(result, "[[") table.insert(result, k) table.insert(result, ":") table.insert(result, v[1]) table.insert(result, "]]") end end return table.concat(result, "") end function m.Z(frame) local args=frame and (frame.args or frame) or {}; local czy=(type(frame)=="table") local text=czy and args[1] or (not czy and frame); local ze = { "^%s*[Mm][Nn][Ii][Ee]$", "^%s*[Mm][Nn][Ii][Ee]%s", "^%s*[Mm][Nn][Ąą]$", "^%s*[Mm][Nn][Ąą]%s", "^%s*[Ss][Oo][Bb][Ąą]$", "^%s*[Ss][Oo][Bb][Ąą]%s", "^%s*[Ss][Zz][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwZzŹźŻż]", "^%s*[Ss][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwŹźŻż]", "^%s*[Ww][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwZzŹźŻż]", "^%s*[ŹźZz][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwZzŹźŻż]", "^%s*%[%[[Ss][Zz][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwZzŹźŻż]", "^%s*%[%[[Ss][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwŹźŻż]", "^%s*%[%[[ŹźZz][BbCcĆćDdFfGgHhJjKkLlŁłMmNnŃńPpRrSsŚśTtWwZzŹźŻż]", } if text then for _, regex in ipairs(ze) do mw.log(regex); if mw.ustring.match(text, regex) then return "ze" end end end return "z" end function m.TEMPLATENAME(frame) local templateTitle = mw.title.new(frame:getParent():getTitle()) return (templateTitle and (templateTitle.namespace == 10)) and templateTitle.text or nil end function m.SUBST(frame) local title = mw.title.getCurrentTitle() mw.logObject(title.text, "title.text") local prefixedTitleName = mw.ustring.match(title.prefixedText, "^(.-)/opis") or mw.ustring.match(title.prefixedText, "^(.-)/test") or mw.ustring.match(title.prefixedText, "^(.-)/brudnopis") or title.prefixedText if mw.isSubsting() or (prefixedTitleName == frame:getParent():getTitle()) or (frame:getParent().args["usprawiedliwienie na brak 'subst:'"] == "przykład wywołania szablonu przez transkluzję poza stronami testowymi") then return frame.args[1] end mw.log("Brak 'subst:' w wywołaniu '"..frame:getParent():getTitle().."'") return "[[Kategoria:Brak 'subst:' w wywołaniu szablonu]]" end function m.Format(frame) local templateTitle = mw.title.new(frame:getParent():getTitle()) local params = {} local i = 1 while i do local arg = frame.args[i] if arg then table.insert(params, arg) i = i + 1 else i = false end end if #params > 0 then return mw.ustring.format(unpack(params)) end end function m.SimpleDuplicates(frame) local result = {} local wikitext = mw.title.getCurrentTitle():getContent() if not wikitext then -- no page return end while true do local templateIterator = mw.ustring.gmatch(wikitext, "{{[^{}]+}}") while true do local template = templateIterator() if not template then -- no more templates break end mw.log(template) local parameters = {} local patch, _ = mw.ustring.gsub(template, "(%[%[[^%[%]|]+)|([^%[%]|]-%]%])", "%1<nowiki>&x7C;</nowiki>%2") local chunks = mw.text.split(patch, "|") local i = 2 -- skip first item which is template name local auto = 0 local emited = false while i <= #chunks do local chunk = chunks[i] local name, value = mw.ustring.match(chunk, "%s*(.-)%s*=(.*)") if not name then auto = auto + 1 name = tostring(auto) value = chunk end value = mw.ustring.gsub(value, "<nowiki>&x7C;</nowiki>", "|") if not parameters[name] then parameters[name] = { value } else -- duplicated parameter if not emited then emited = {} table.insert(emited, "<tt>"..mw.text.nowiki(template).."</tt>") end if #parameters[name] == 1 then table.insert(emited, name..": "..mw.text.nowiki(parameters[name][1])) end table.insert(parameters[name], value) table.insert(emited, name..": "..mw.text.nowiki(value)) end i = i + 1 end if emited then table.insert(result, table.concat(emited, "<br /> → ")) end end local count = false wikitext, count = mw.ustring.gsub(wikitext, "{{[^{}]+}}", "€") if count == 0 then break end end if #result > 0 then return "<ul><li>"..table.concat(result, "</li><li>").."</li></ul>" end end function m.NavboxWidth(frame) local style = frame.args[1] if string.match(style, ";%s*float%s*:%s*right%s*;") then return string.match(style, ";%s*width%s*:%s*([0-9]+px)%s*;") or string.match(style, ";%s*width%s*:%s*([0-9]+em)%s*;") or string.match(style, ";%s*width%s*:%s*(auto)%s*;") end end function m.NoWrapDates(frame) local yes = "tak" local fixedDates = {} local fixedMarkerFormat = "\127_FixedDate%d_\127" local fixedMarkerPattern = "\127_FixedDate(%d+)_\127" local patterns = { "%[%[(%d%d?)%s+(%l+)%]%]%s+%[%[(%d%d%d%d) p%.n%.e%.%]%]", "(%d%d?)%s+(%l+)%s+(%d%d%d%d) p%.n%.e%.", "%[%[(%d%d?)%s+(%l+)%]%]%s+%[%[(%d%d%d%d)%]%]", "(%d%d?)%s+(%l+)%s+(%d%d%d%d)", } local months = require("Moduł:Cytuj/dane").monthparser function customPattern(variant, plain) if not variant then return "" elseif #variant == 0 then return "%s*" elseif plain then return mw.ustring.gsub( variant, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ) else return variant end end local text = frame.args[1] local plain = (frame.args.plain == yes) or (frame.args.plain == 1) local attachLeft = "("..customPattern(frame.args.left, plain) local attachRight = customPattern(frame.args.right, plain)..")" function NoWrapDate(full, day, month, year) local d = tonumber(day) local m = months[month] local y = tonumber(year) if not months[month] or (d <= 0) or (d > 31) then return null end local result = mw.html.create("span") :css("white-space", "nowrap") :wikitext(full) table.insert(fixedDates, tostring(result)) local fixedIndex = #fixedDates return string.format(fixedMarkerFormat, fixedIndex) end for i, v in ipairs(patterns) do text, _ = mw.ustring.gsub(text, attachLeft..v..attachRight, NoWrapDate) end text = string.gsub(text, fixedMarkerPattern, function(n) return fixedDates[tonumber(n)] end) return text end function m.Encode(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); return html and mw.text.encode(html) or html end function m.unstripNoWiki(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); return tekst and mw.text.unstripNoWiki(tekst) or tekst end return m opetksvrhgqqclqxw7kg43hau774n9o 828 56560 539907 539798 2026-04-15T11:18:46Z Persino 2851 539907 Scribunto text/plain local p={}; p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"([%|%[%]%(%)%+%-%*%?%.%^%$%%'])",function (s) return "&#"..tostring(mw.ustring.byte(s))..";";end) return tekst; end; p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"&#(%d+);",function (s) return tostring(mw.ustring.char(s));end); tekst=mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16));end); return tekst; end; function p.ZnakiSpecjalneTaguNowiki(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([%!{}|=<>%[%]])",tab_nawiasy); return tekst; end; function p.ZnakiSpecjalneWikiLinku(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([{}|<>%[%]])",tab_nawiasy); return tekst; end; function p.EncodeSpecjalneZnakiHtml(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; html=mw.ustring.gsub(html,"([{}|<>%[%]#=%?&])",tab_nawiasy); return html; end; function p.EncodeZnakProloguList(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; local lista_znaki="%#%*%;%:"; tekst=mw.ustring.gsub(tekst,"^\n?(["..lista_znaki.."])",tab_nawiasy); tekst=mw.ustring.gsub(tekst,"\n(["..lista_znaki.."])",function(znak) return "\n"..(tab_nawiasy[znak] or znak); end); return tekst; end; function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=%?&])",tabela_nawiasowa); return tekst; end; function p.PrzypisanieZnakoweEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=])",tabela_nawiasowa); return tekst; end; function p.ZamianaDwukropkaNaKodHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([:])",tabela_nawiasowa); return tekst; end; function p.KodHTMLZnaku(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local znak=PobierzParametr(1); if(not parametry_modul.CzyTak(znak))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local czy_tak=parametry_modul["CzyTakCiąg"](czy_kod_znaku); if(czy_tak)then return "&amp;#"..tostring(mw.ustring.byte(znak))..";"; else return "&#"..tostring(mw.ustring.byte(znak))..";"; end; end; p["KodyHTMLZnakówWikiCiągu"] = function (frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local ciag_znakow=PobierzParametr(1); if(not parametry_modul.CzyTak(ciag_znakow))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_znakowo_kodowa={}; local tabela_znakowa=html_dane_modul.tabela_znakowa; local ciag,_=mw.ustring.gsub(ciag_znakow,"(.)",function(znak) if(tabela_znakowa[znak])then if(not czy_kod_znaku)then return "&"..tabela_znakowa[znak]..";"; else return "&amp;"..tabela_znakowa[znak]..";"; end; end; return nil; end); return ciag; end; function p.EncodeId(id,bez_transformacji) id=(not bez_transformacji) and p.DecodeHtml(id,true) or id; local id=p.EncodeSpecjalneZnakiHtml(id); return id; end; function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr) parametr=mw.ustring.gsub(parametr,"‎",""); return parametr; end; function p.EncodeWiki(parametr,czy_nie_odstepy) parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); local parametry_modul=require("Module:Parametry"); if(not czy_nie_odstepy)then parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",[3]="tak",}; end; parametr=mw.text.encode(parametr); return parametr; end; function p.DecodeWiki(parametr,czy_nie_odstepy) parametr=mw.text.decode(parametr); parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); if(not czy_nie_odstepy)then local parametry_modul=require("Module:Parametry"); parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",}; end; return parametr; end; function p.IsEncodedHtml(parametr,encode,encode_real) local parametry_modul=require("Module:Parametry"); local spr_parametr_szereg=nil; local TempFunParametr=function(parametr) if(parametry_modul.TypeNil(spr_parametr_szereg))then local __spr_parametr_szereg=mw.ustring.match(parametr,"^[%w%p%s]*$"); spr_parametr_szereg=__spr_parametr_szereg and true or false; return spr_parametr_szereg; end; return spr_parametr_szereg; end; local spr_parametr_bez_procentu=nil; local TempFunBezProcentu=function(parametr) if(parametry_modul.TypeNil(spr_parametr_bez_procentu))then local __spr_parametr_bez_procentu=mw.ustring.match(parametr,"^[^%%]*$"); spr_parametr_bez_procentu=__spr_parametr_bez_procentu and true or false; return spr_parametr_bez_procentu; end; return spr_parametr_bez_procentu; end; local wynik=((encode_real)and(TempFunParametr(parametr)and(TempFunBezProcentu(parametr)))) or((encode)and(TempFunBezProcentu(parametr))) or(((not encode_real)or((encode_real)and(TempFunParametr(parametr)))) and(mw.ustring.match(parametr,"%%%x%x")) and(not mw.ustring.match(parametr,"%%$")) and(not mw.ustring.match(parametr,"%%.$")) and(not mw.ustring.match(parametr,"%%[^%x].")) and(not mw.ustring.match(parametr,"%%.[^%x]"))); return wynik and true or false; end; function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then return p.EncodeWiki(parametr,czy_nie_odstepy); end; return mw.uri.encode(parametr,"WIKI"); end; function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then if(spacje)then return p.DecodeWiki(mw.uri.decode(parametr,"WIKI")); else return p.EncodeWiki(mw.uri.decode(parametr,"WIKI")); end; end; if(spacje)then return p.DecodeWiki(parametr,czy_nie_odstepy); else return p.EncodeWiki(parametr,czy_nie_odstepy); end; end; function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik) znacznik=mw.ustring.gsub(znacznik,"([\"'])(.-)(%1)",function(cudzyslow_otwierajacy,atrybut,cudzyslow_zamykajacy) local ile1;local ile2; atrybut,ile1=mw.ustring.gsub(atrybut,"([<>&])",function(a) return mw.text.encode(a); end); atrybut,ile2=mw.ustring.gsub(atrybut,"(\\\")",function(a) return p["KodyHTMLZnakówWikiCiągu"](a); end); if(ile1+ile2>0)then return cudzyslow_otwierajacy..atrybut..cudzyslow_zamykajacy; end; return nil; end); return znacznik; end; function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value) value=mw.ustring.gsub(value,"(&)(%a+)(;)",function(amp,kod_html,srednik) kod_html=mw.ustring.lower(kod_html); if((kod_html=="lt")or(kod_html=="gt")or(kod_html=="amp"))then return mw.text.decode(amp..kod_html..srednik); end; return nil; end); local lewy_ukosnik=mw.ustring.byte("\\"); local cudzyslow=mw.ustring.byte("\""); value=mw.ustring.gsub(value,"(&#"..lewy_ukosnik..";&#"..cudzyslow..";)","\\\""); return value; end; p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_nie_dolne_myslniki=PobierzParametr("z nie dolnymi z myślnikami") or PobierzParametr(2) or czy_nie_dolne_myslniki; czy_nie_dolne_myslniki=parametry_modul.CzyTak(czy_nie_dolne_myslniki); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; local naglowek=czy_nie_dolne_myslniki and mw.ustring.match(nazwa_jednostki,"^[^#]*#[%s_]*(.-)[%s_]*$") or mw.ustring.match(nazwa_jednostki,"^[^#]*#(.-)%s*$"); naglowek=parametry_modul["Odstępy"]{[1]=naglowek,[2]="tak",[3]=((not czy_nie_dolne_myslniki)and "tak" or nil),}; return naglowek; end; p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?[%s_]*([^&]+=[^&]-.-)[%s_]*$"); if(parametry)then parametry=mw.ustring.gsub(parametry,"[%s_]*=[%s_]*","=") or nil; parametry=mw.ustring.gsub(parametry,"[%s_]*&[%s_]*","&") or nil; end; return parametry; else local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?([^&]+=[^&]-.-)%s*$"); return parametry; end; end; p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)[%s_]*%?[^&]+=[^&]*.*$","%1"); else nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)%?[^&]+=[^&]*.*$","%1"); end; local strony_modul=require("Module:Strony"); local czy_url=strony_modul.SprawdzanieURL(nazwa_jednostki); czy_url=czy_url and true or (not czy_naprawiaj); nazwa_jednostki=parametry_modul["Odstępy"]{[1]=nazwa_jednostki,[2]="tak",[3]=czy_url and true or false,}; return nazwa_jednostki; end; p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local parametry_strony=PobierzParametr("parametry") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(parametry_modul.CzyTak(parametry_strony))then local nazwa_strony_linku; if(czy_naprawiaj)then if(mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&[%s_]*title[%s_]*=([^&]+).*$",""); end; else if(mw.ustring.match(parametry_strony,"^title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^title=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&title=([^&]+).*$",""); end; end; nazwa_strony_linku=parametry_modul["Odstępy"]{[1]=nazwa_strony_linku,[2]="tak",[3]=(not czy_naprawiaj),}; return nazwa_strony_linku,parametry_strony; else return nil; end; end; p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); local tabela_nazw_adresu=tabela_nazw_adresu or {}; local adres=p["NazwaStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local parametry_strony=p["ParametryStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local naglowek_strony=p["NagłówekStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); nazwa_jednostki=adres..(parametry_strony and ("?"..parametry_strony) or "")..(naglowek_strony and ("#"..naglowek_strony) or ""); return nazwa_jednostki; end; p["URLStrona"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local z_ukosnikiem=parametry_modul.CzyTak(PobierzParametr("ukośnik") or PobierzParametr(2)); local serwer,nazwa=mw.ustring.match(url,"^//+([^%s/]+)"..((z_ukosnikiem) and "/" or "").."(/?.-)$"); return serwer,nazwa; end; p["UrlBezProtokołu"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local mail=mw.ustring.match(url,"^.*@([^@]+)$"); if(mail)then return "//"..mail,"mail",1; end; local protokol,strona=mw.ustring.match(url,"^(%a+:)(/+.-)$"); if((protokol)and(strona))then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,protokol,2; end; local strona=mw.ustring.match(url,"^:?(/+.-)$"); if(strona)then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,nil,3; end; return "//"..url,nil,-1; end; function p.DecodeKoduHTMLZnaku(tekst) local html_dane_modul=mw.loadData("Module:Html/dane"); local kody_literowe_html_i_ich_odpowiedniki_znakowe=html_dane_modul.kody_literowe_html_i_ich_odpowiedniki_znakowe; -- najpierw nazwane encje tekst = mw.ustring.gsub(tekst,"(&%a+%;)", kody_literowe_html_i_ich_odpowiedniki_znakowe); -- encje numeryczne dziesiętne: &#956; tekst=mw.ustring.gsub(tekst,"&#(%d+);", function(n) return mw.ustring.char(tonumber(n)) end); -- encje numeryczne szesnastkowe: &#x3BC; tekst = mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16)) end); return tekst; end; function p.ZamianaEncodeTekst(tekst) tekst=mw.uri.encode(mw.uri.decode(tekst,"PATH"),"PATH"); return tekst; end; function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor) tekst=mw.ustring.gsub(tekst,wzor,function(tekst) tekst=p.ZamianaEncodeTekst(tekst); return tekst; end); return tekst; end; function p.StronaParametryIdentyfikacja(adres) local ile_w;local ile; adres,ile_w,ile=p.EncodeHashKoduHtmlTekstu(adres); local ile1;local ile2; if(ile_w>0)then adres,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(adres); end; local strona,naglowek=mw.ustring.match(adres,"^[%s_]*([^#]-)[%s_]*#[%s_]*(.-)[%s_]*$"); if((not strona)or(not naglowek))then strona=mw.ustring.match(adres,"^[%s_]*(.-)[%s_]*$"); end; local __strona,parametry=mw.ustring.match(strona,"^(.-%?*)%?([^&=]-=.*)$"); strona=__strona or strona; if(ile_w>0)then strona=p.DecodeTempHashKoduHtmlTekstu(strona,ile1,ile2); parametry=parametry and p.DecodeTempHashKoduHtmlTekstu(parametry,ile1,ile2) or nil; naglowek=naglowek and p.DecodeTempHashKoduHtmlTekstu(naglowek,ile1,ile2) or nil; end; return strona,parametry,naglowek,ile; end; function p.TworzenieAdresuHtml(strona,parametry,naglowek,ile) local adres=strona..(parametry and ("?"..parametry) or "")..((naglowek)and ("#"..naglowek) or ""); adres=p.DecodeHashKoduHtmlTekstu(adres,ile); return adres; end; function p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek) local strona,parametry,naglowek,ile=p.StronaParametryIdentyfikacja(adres); strona=funkcja_strona and funkcja_strona(strona) or strona; parametry=(parametry and funkcja_parametry) and funkcja_parametry(parametry) or parametry; naglowek=(naglowek and funkcja_naglowek) and funkcja_naglowek(naglowek) or naglowek; local adres=p.TworzenieAdresuHtml(strona,parametry,naglowek,ile); return adres; end; function p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) local function ParametryEncodeURL(a,b,c) return a..p.ZamianaEncodeTekst(b).."="..p.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; if(not w_adresie)then return OperacjeHtml(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeHtml,funkcja_naglowek); end; end; function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) function ParametryZaawansowanyEncodeURL(a,b,c) b=mw.uri.decode(b,"PATH");b=p.EncodeSpecjalneZnakiHtml(b);b=mw.uri.encode(b,"PATH"); c=mw.uri.decode(c,"PATH");c=p.EncodeSpecjalneZnakiHtml(c);c=mw.uri.encode(c,"PATH"); return a..(b.."="..c); end; local function OperacjeURL(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); return adres; end; if(not w_adresie)then return OperacjeURL(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeURL,funkcja_naglowek); end; end; function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek) local EncodeHtmlAB=function(a,b,c) b=p.EncodeHtml(b);c=p.EncodeHtml(c); return a..b.."="..c; end; local function ParametryHtml(parametr) parametr=mw.ustring.gsub(parametr,"^(%??)([^&=]*)=([^&]*)",EncodeHtmlAB); parametr=mw.ustring.gsub(parametr,"(&)([^&=]*)=([^&]*)",EncodeHtmlAB); return parametr; end; if(not w_adresie)then return ParametryHtml(parametr); else return p.TworzenieStronaParametryIdentyfikacja(parametr,funkcja_strona,ParametryHtml,funkcja_naglowek); end; end; function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek) local KrokEncodeZaawansowanyParametryHtmlABC=function(a) a=mw.uri.decode(a,"PATH"); a=p.EncodePodstawoweHtmlTekstu(a); if(z_kodowaniem)then a=mw.uri.encode(a,"PATH");end; return a; end; local EncodeZaawansowanyParametryHtmlABC=function(a,b,c) b=KrokEncodeZaawansowanyParametryHtmlABC(b); c=KrokEncodeZaawansowanyParametryHtmlABC(c); return (a or "")..(b.."="..c); end; local function OperacjeParametryHtmlABC(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); adres=mw.ustring.gsub(adres,"([&])([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); return adres; end; if(not w_adresie)then return OperacjeParametryHtmlABC(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeParametryHtmlABC,funkcja_naglowek); end; end; function p.EncodeHashKoduHtmlTekstu(tekst) local ile;local ile2=0; tekst,ile=mw.ustring.gsub(tekst,"&([^&;%s]);",function(kod) if((kod=="num")or(kod=="#35")or(kod=="#x23"))then ile2=ile2+1; return "&amp;num;"; end; return nil; end); return tekst,ile,ile2; end; function p.DecodeHashKoduHtmlTekstu(tekst,ile) if(((ile)and(ile>0))or(not ile))then tekst=mw.ustring.gsub(tekst,"&num;",function(kod) return "&#35;"; end); end; return tekst; end; function p.EncodeTempHashKoduHtmlTekstu(tekst) local ile1;local ile2; tekst,ile1=mw.ustring.gsub(tekst,"&#(%d+);",function(kod) return "&&num;"..kod..";"; end); tekst,ile2=mw.ustring.gsub(tekst,"&#x(%x+);",function(kod) return "&&num;x"..kod..";"; end); return tekst,ile1,ile2; end; function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2) if(((ile1)and(ile1>0))or(not ile1))then tekst=mw.ustring.gsub(tekst,"&&num;(%d+);",function(kod) return "&#"..kod..";" end); end; if(((ile2)and(ile2>0))or(not ile2))then tekst=mw.ustring.gsub(tekst,"&&num;x(%x+);",function(kod) return "&#x"..kod..";" end); end; return tekst; end; function p.AdresBezProtokolarnyEncodeURL(adres) local adres=p.ParametryEncodeURL(adres,true, function(strona) strona=p.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=p.ZamianaEncodeTekst(naglowek); return naglowek; end); return adres; end; function p.UriEncode(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); html=mw.ustring.gsub(html,"^(%a+://)(.+)$",function(prot,strona) return prot..p.AdresBezProtokolarnyEncodeURL(strona); end); return html; end; function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony) local ile; elementy_adresu_strony,ile=p.EncodeHashKoduHtmlTekstu(elementy_adresu_strony); if(ile>0)then elementy_adresu_strony=p.DecodeKoduHTMLZnaku(elementy_adresu_strony); end; elementy_adresu_strony=p.EncodeSpecjalneZnakiHtml(elementy_adresu_strony); return elementy_adresu_strony; end; function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem) if(czy_parametry_strony)then elementy_adresu_strony=p.EncodeZaawansowanyParametryHtml(elementy_adresu_strony,z_kodowaniem); else elementy_adresu_strony=mw.uri.decode(elementy_adresu_strony,"PATH"); elementy_adresu_strony=p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony); if(z_kodowaniem)then elementy_adresu_strony=mw.uri.encode(elementy_adresu_strony,"PATH");end; end; return elementy_adresu_strony; end; function p.AdresProjektuEncodeHtml(frame,z_kodowaniem) local parametry_modul=require("Module:Parametry") local PobierzParametry=parametry_modul.PobierzParametryRamki(frame); local html=PobierzParametry("html"); local z_kodowaniem_html=PobierzParametry("encode"); if(z_kodowaniem_html)then z_kodowaniem=parametry_modul.CzyTak(z_kodowaniem_html);end; local html=p.EncodeZaawansowanyParametryHtml(html,z_kodowaniem,true, function(strona) strona=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(strona,"PATH")); if(z_kodowaniem)then strona=mw.uri.encode(strona,"PATH");end; return strona; end, function(naglowek) naglowek=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(naglowek,"PATH")); if(z_kodowaniem)then naglowek=mw.uri.encode(naglowek,"PATH") end; return naglowek; end); return html; end; return p; 8bbyxo2f9ud0o1i9asfdkjv8nd346rc 539909 539907 2026-04-15T11:39:15Z Persino 2851 539909 Scribunto text/plain local p={}; p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"([%|%[%]%(%)%+%-%*%?%.%^%$%%'])",function (s) return "&#"..tostring(mw.ustring.byte(s))..";";end) return tekst; end; p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"&#(%d+);",function (s) return tostring(mw.ustring.char(s));end); tekst=mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16));end); return tekst; end; function p.ZnakiSpecjalneTaguNowiki(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([%!{}|=<>%[%]])",tab_nawiasy); return tekst; end; function p.ZnakiSpecjalneWikiLinku(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([{}|<>%[%]])",tab_nawiasy); return tekst; end; function p.EncodeSpecjalneZnakiHtml(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; html=mw.ustring.gsub(html,"([{}|<>%[%]#=%?&])",tab_nawiasy); return html; end; function p.EncodeZnakProloguList(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; local lista_znaki="%#%*%;%:"; tekst=mw.ustring.gsub(tekst,"^\n?(["..lista_znaki.."])",tab_nawiasy); tekst=mw.ustring.gsub(tekst,"\n(["..lista_znaki.."])",function(znak) return "\n"..(tab_nawiasy[znak] or znak); end); return tekst; end; function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=%?&])",tabela_nawiasowa); return tekst; end; function p.PrzypisanieZnakoweEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=])",tabela_nawiasowa); return tekst; end; function p.ZamianaDwukropkaNaKodHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([:])",tabela_nawiasowa); return tekst; end; function p.KodHTMLZnaku(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local znak=PobierzParametr(1); if(not parametry_modul.CzyTak(znak))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local czy_tak=parametry_modul["CzyTakCiąg"](czy_kod_znaku); if(czy_tak)then return "&amp;#"..tostring(mw.ustring.byte(znak))..";"; else return "&#"..tostring(mw.ustring.byte(znak))..";"; end; end; p["KodyHTMLZnakówWikiCiągu"] = function (frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local ciag_znakow=PobierzParametr(1); if(not parametry_modul.CzyTak(ciag_znakow))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_znakowo_kodowa={}; local tabela_znakowa=html_dane_modul.tabela_znakowa; local ciag,_=mw.ustring.gsub(ciag_znakow,"(.)",function(znak) if(tabela_znakowa[znak])then if(not czy_kod_znaku)then return "&#"..tabela_znakowa[znak]..";"; else return "&amp;&num;"..tabela_znakowa[znak]..";"; end; end; return nil; end); return ciag; end; function p.EncodeId(id,bez_transformacji) id=(not bez_transformacji) and p.DecodeHtml(id,true) or id; local id=p.EncodeSpecjalneZnakiHtml(id); return id; end; function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr) parametr=mw.ustring.gsub(parametr,"‎",""); return parametr; end; function p.EncodeWiki(parametr,czy_nie_odstepy) parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); local parametry_modul=require("Module:Parametry"); if(not czy_nie_odstepy)then parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",[3]="tak",}; end; parametr=mw.text.encode(parametr); return parametr; end; function p.DecodeWiki(parametr,czy_nie_odstepy) parametr=mw.text.decode(parametr); parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); if(not czy_nie_odstepy)then local parametry_modul=require("Module:Parametry"); parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",}; end; return parametr; end; function p.IsEncodedHtml(parametr,encode,encode_real) local parametry_modul=require("Module:Parametry"); local spr_parametr_szereg=nil; local TempFunParametr=function(parametr) if(parametry_modul.TypeNil(spr_parametr_szereg))then local __spr_parametr_szereg=mw.ustring.match(parametr,"^[%w%p%s]*$"); spr_parametr_szereg=__spr_parametr_szereg and true or false; return spr_parametr_szereg; end; return spr_parametr_szereg; end; local spr_parametr_bez_procentu=nil; local TempFunBezProcentu=function(parametr) if(parametry_modul.TypeNil(spr_parametr_bez_procentu))then local __spr_parametr_bez_procentu=mw.ustring.match(parametr,"^[^%%]*$"); spr_parametr_bez_procentu=__spr_parametr_bez_procentu and true or false; return spr_parametr_bez_procentu; end; return spr_parametr_bez_procentu; end; local wynik=((encode_real)and(TempFunParametr(parametr)and(TempFunBezProcentu(parametr)))) or((encode)and(TempFunBezProcentu(parametr))) or(((not encode_real)or((encode_real)and(TempFunParametr(parametr)))) and(mw.ustring.match(parametr,"%%%x%x")) and(not mw.ustring.match(parametr,"%%$")) and(not mw.ustring.match(parametr,"%%.$")) and(not mw.ustring.match(parametr,"%%[^%x].")) and(not mw.ustring.match(parametr,"%%.[^%x]"))); return wynik and true or false; end; function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then return p.EncodeWiki(parametr,czy_nie_odstepy); end; return mw.uri.encode(parametr,"WIKI"); end; function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then if(spacje)then return p.DecodeWiki(mw.uri.decode(parametr,"WIKI")); else return p.EncodeWiki(mw.uri.decode(parametr,"WIKI")); end; end; if(spacje)then return p.DecodeWiki(parametr,czy_nie_odstepy); else return p.EncodeWiki(parametr,czy_nie_odstepy); end; end; function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik) znacznik=mw.ustring.gsub(znacznik,"([\"'])(.-)(%1)",function(cudzyslow_otwierajacy,atrybut,cudzyslow_zamykajacy) local ile1;local ile2; atrybut,ile1=mw.ustring.gsub(atrybut,"([<>&])",function(a) return mw.text.encode(a); end); atrybut,ile2=mw.ustring.gsub(atrybut,"(\\\")",function(a) return p["KodyHTMLZnakówWikiCiągu"](a); end); if(ile1+ile2>0)then return cudzyslow_otwierajacy..atrybut..cudzyslow_zamykajacy; end; return nil; end); return znacznik; end; function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value) value=mw.ustring.gsub(value,"(&)(%a+)(;)",function(amp,kod_html,srednik) kod_html=mw.ustring.lower(kod_html); if((kod_html=="lt")or(kod_html=="gt")or(kod_html=="amp"))then return mw.text.decode(amp..kod_html..srednik); end; return nil; end); local lewy_ukosnik=mw.ustring.byte("\\"); local cudzyslow=mw.ustring.byte("\""); value=mw.ustring.gsub(value,"(&#"..lewy_ukosnik..";&#"..cudzyslow..";)","\\\""); return value; end; p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_nie_dolne_myslniki=PobierzParametr("z nie dolnymi z myślnikami") or PobierzParametr(2) or czy_nie_dolne_myslniki; czy_nie_dolne_myslniki=parametry_modul.CzyTak(czy_nie_dolne_myslniki); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; local naglowek=czy_nie_dolne_myslniki and mw.ustring.match(nazwa_jednostki,"^[^#]*#[%s_]*(.-)[%s_]*$") or mw.ustring.match(nazwa_jednostki,"^[^#]*#(.-)%s*$"); naglowek=parametry_modul["Odstępy"]{[1]=naglowek,[2]="tak",[3]=((not czy_nie_dolne_myslniki)and "tak" or nil),}; return naglowek; end; p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?[%s_]*([^&]+=[^&]-.-)[%s_]*$"); if(parametry)then parametry=mw.ustring.gsub(parametry,"[%s_]*=[%s_]*","=") or nil; parametry=mw.ustring.gsub(parametry,"[%s_]*&[%s_]*","&") or nil; end; return parametry; else local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?([^&]+=[^&]-.-)%s*$"); return parametry; end; end; p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)[%s_]*%?[^&]+=[^&]*.*$","%1"); else nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)%?[^&]+=[^&]*.*$","%1"); end; local strony_modul=require("Module:Strony"); local czy_url=strony_modul.SprawdzanieURL(nazwa_jednostki); czy_url=czy_url and true or (not czy_naprawiaj); nazwa_jednostki=parametry_modul["Odstępy"]{[1]=nazwa_jednostki,[2]="tak",[3]=czy_url and true or false,}; return nazwa_jednostki; end; p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local parametry_strony=PobierzParametr("parametry") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(parametry_modul.CzyTak(parametry_strony))then local nazwa_strony_linku; if(czy_naprawiaj)then if(mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&[%s_]*title[%s_]*=([^&]+).*$",""); end; else if(mw.ustring.match(parametry_strony,"^title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^title=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&title=([^&]+).*$",""); end; end; nazwa_strony_linku=parametry_modul["Odstępy"]{[1]=nazwa_strony_linku,[2]="tak",[3]=(not czy_naprawiaj),}; return nazwa_strony_linku,parametry_strony; else return nil; end; end; p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); local tabela_nazw_adresu=tabela_nazw_adresu or {}; local adres=p["NazwaStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local parametry_strony=p["ParametryStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local naglowek_strony=p["NagłówekStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); nazwa_jednostki=adres..(parametry_strony and ("?"..parametry_strony) or "")..(naglowek_strony and ("#"..naglowek_strony) or ""); return nazwa_jednostki; end; p["URLStrona"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local z_ukosnikiem=parametry_modul.CzyTak(PobierzParametr("ukośnik") or PobierzParametr(2)); local serwer,nazwa=mw.ustring.match(url,"^//+([^%s/]+)"..((z_ukosnikiem) and "/" or "").."(/?.-)$"); return serwer,nazwa; end; p["UrlBezProtokołu"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local mail=mw.ustring.match(url,"^.*@([^@]+)$"); if(mail)then return "//"..mail,"mail",1; end; local protokol,strona=mw.ustring.match(url,"^(%a+:)(/+.-)$"); if((protokol)and(strona))then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,protokol,2; end; local strona=mw.ustring.match(url,"^:?(/+.-)$"); if(strona)then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,nil,3; end; return "//"..url,nil,-1; end; function p.DecodeKoduHTMLZnaku(tekst) local html_dane_modul=mw.loadData("Module:Html/dane"); local kody_literowe_html_i_ich_odpowiedniki_znakowe=html_dane_modul.kody_literowe_html_i_ich_odpowiedniki_znakowe; -- najpierw nazwane encje tekst = mw.ustring.gsub(tekst,"(&%a+%;)", kody_literowe_html_i_ich_odpowiedniki_znakowe); -- encje numeryczne dziesiętne: &#956; tekst=mw.ustring.gsub(tekst,"&#(%d+);", function(n) return mw.ustring.char(tonumber(n)) end); -- encje numeryczne szesnastkowe: &#x3BC; tekst = mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16)) end); return tekst; end; function p.ZamianaEncodeTekst(tekst) tekst=mw.uri.encode(mw.uri.decode(tekst,"PATH"),"PATH"); return tekst; end; function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor) tekst=mw.ustring.gsub(tekst,wzor,function(tekst) tekst=p.ZamianaEncodeTekst(tekst); return tekst; end); return tekst; end; function p.StronaParametryIdentyfikacja(adres) local ile_w;local ile; adres,ile_w,ile=p.EncodeHashKoduHtmlTekstu(adres); local ile1;local ile2; if(ile_w>0)then adres,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(adres); end; local strona,naglowek=mw.ustring.match(adres,"^[%s_]*([^#]-)[%s_]*#[%s_]*(.-)[%s_]*$"); if((not strona)or(not naglowek))then strona=mw.ustring.match(adres,"^[%s_]*(.-)[%s_]*$"); end; local __strona,parametry=mw.ustring.match(strona,"^(.-%?*)%?([^&=]-=.*)$"); strona=__strona or strona; if(ile_w>0)then strona=p.DecodeTempHashKoduHtmlTekstu(strona,ile1,ile2); parametry=parametry and p.DecodeTempHashKoduHtmlTekstu(parametry,ile1,ile2) or nil; naglowek=naglowek and p.DecodeTempHashKoduHtmlTekstu(naglowek,ile1,ile2) or nil; end; return strona,parametry,naglowek,ile; end; function p.TworzenieAdresuHtml(strona,parametry,naglowek,ile) local adres=strona..(parametry and ("?"..parametry) or "")..((naglowek)and ("#"..naglowek) or ""); adres=p.DecodeHashKoduHtmlTekstu(adres,ile); return adres; end; function p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek) local strona,parametry,naglowek,ile=p.StronaParametryIdentyfikacja(adres); strona=funkcja_strona and funkcja_strona(strona) or strona; parametry=(parametry and funkcja_parametry) and funkcja_parametry(parametry) or parametry; naglowek=(naglowek and funkcja_naglowek) and funkcja_naglowek(naglowek) or naglowek; local adres=p.TworzenieAdresuHtml(strona,parametry,naglowek,ile); return adres; end; function p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) local function ParametryEncodeURL(a,b,c) return a..p.ZamianaEncodeTekst(b).."="..p.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; if(not w_adresie)then return OperacjeHtml(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeHtml,funkcja_naglowek); end; end; function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) function ParametryZaawansowanyEncodeURL(a,b,c) b=mw.uri.decode(b,"PATH");b=p.EncodeSpecjalneZnakiHtml(b);b=mw.uri.encode(b,"PATH"); c=mw.uri.decode(c,"PATH");c=p.EncodeSpecjalneZnakiHtml(c);c=mw.uri.encode(c,"PATH"); return a..(b.."="..c); end; local function OperacjeURL(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); return adres; end; if(not w_adresie)then return OperacjeURL(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeURL,funkcja_naglowek); end; end; function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek) local EncodeHtmlAB=function(a,b,c) b=p.EncodeHtml(b);c=p.EncodeHtml(c); return a..b.."="..c; end; local function ParametryHtml(parametr) parametr=mw.ustring.gsub(parametr,"^(%??)([^&=]*)=([^&]*)",EncodeHtmlAB); parametr=mw.ustring.gsub(parametr,"(&)([^&=]*)=([^&]*)",EncodeHtmlAB); return parametr; end; if(not w_adresie)then return ParametryHtml(parametr); else return p.TworzenieStronaParametryIdentyfikacja(parametr,funkcja_strona,ParametryHtml,funkcja_naglowek); end; end; function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek) local KrokEncodeZaawansowanyParametryHtmlABC=function(a) a=mw.uri.decode(a,"PATH"); a=p.EncodePodstawoweHtmlTekstu(a); if(z_kodowaniem)then a=mw.uri.encode(a,"PATH");end; return a; end; local EncodeZaawansowanyParametryHtmlABC=function(a,b,c) b=KrokEncodeZaawansowanyParametryHtmlABC(b); c=KrokEncodeZaawansowanyParametryHtmlABC(c); return (a or "")..(b.."="..c); end; local function OperacjeParametryHtmlABC(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); adres=mw.ustring.gsub(adres,"([&])([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); return adres; end; if(not w_adresie)then return OperacjeParametryHtmlABC(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeParametryHtmlABC,funkcja_naglowek); end; end; function p.EncodeHashKoduHtmlTekstu(tekst) local ile;local ile2=0; tekst,ile=mw.ustring.gsub(tekst,"&([^&;%s]);",function(kod) if((kod=="num")or(kod=="#35")or(kod=="#x23"))then ile2=ile2+1; return "&amp;num;"; end; return nil; end); return tekst,ile,ile2; end; function p.DecodeHashKoduHtmlTekstu(tekst,ile) if(((ile)and(ile>0))or(not ile))then tekst=mw.ustring.gsub(tekst,"&num;",function(kod) return "&#35;"; end); end; return tekst; end; function p.EncodeTempHashKoduHtmlTekstu(tekst) local ile1;local ile2; tekst,ile1=mw.ustring.gsub(tekst,"&#(%d+);",function(kod) return "&&num;"..kod..";"; end); tekst,ile2=mw.ustring.gsub(tekst,"&#x(%x+);",function(kod) return "&&num;x"..kod..";"; end); return tekst,ile1,ile2; end; function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2) if(((ile1)and(ile1>0))or(not ile1))then tekst=mw.ustring.gsub(tekst,"&&num;(%d+);",function(kod) return "&#"..kod..";" end); end; if(((ile2)and(ile2>0))or(not ile2))then tekst=mw.ustring.gsub(tekst,"&&num;x(%x+);",function(kod) return "&#x"..kod..";" end); end; return tekst; end; function p.AdresBezProtokolarnyEncodeURL(adres) local adres=p.ParametryEncodeURL(adres,true, function(strona) strona=p.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=p.ZamianaEncodeTekst(naglowek); return naglowek; end); return adres; end; function p.UriEncode(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); html=mw.ustring.gsub(html,"^(%a+://)(.+)$",function(prot,strona) return prot..p.AdresBezProtokolarnyEncodeURL(strona); end); return html; end; function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony) local ile; elementy_adresu_strony,ile=p.EncodeHashKoduHtmlTekstu(elementy_adresu_strony); if(ile>0)then elementy_adresu_strony=p.DecodeKoduHTMLZnaku(elementy_adresu_strony); end; elementy_adresu_strony=p.EncodeSpecjalneZnakiHtml(elementy_adresu_strony); return elementy_adresu_strony; end; function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem) if(czy_parametry_strony)then elementy_adresu_strony=p.EncodeZaawansowanyParametryHtml(elementy_adresu_strony,z_kodowaniem); else elementy_adresu_strony=mw.uri.decode(elementy_adresu_strony,"PATH"); elementy_adresu_strony=p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony); if(z_kodowaniem)then elementy_adresu_strony=mw.uri.encode(elementy_adresu_strony,"PATH");end; end; return elementy_adresu_strony; end; function p.AdresProjektuEncodeHtml(frame,z_kodowaniem) local parametry_modul=require("Module:Parametry") local PobierzParametry=parametry_modul.PobierzParametryRamki(frame); local html=PobierzParametry("html"); local z_kodowaniem_html=PobierzParametry("encode"); if(z_kodowaniem_html)then z_kodowaniem=parametry_modul.CzyTak(z_kodowaniem_html);end; local html=p.EncodeZaawansowanyParametryHtml(html,z_kodowaniem,true, function(strona) strona=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(strona,"PATH")); if(z_kodowaniem)then strona=mw.uri.encode(strona,"PATH");end; return strona; end, function(naglowek) naglowek=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(naglowek,"PATH")); if(z_kodowaniem)then naglowek=mw.uri.encode(naglowek,"PATH") end; return naglowek; end); return html; end; return p; 0qfzakn56vreddogif78kcm24bhdomv 539910 539909 2026-04-15T11:40:31Z Persino 2851 539910 Scribunto text/plain local p={}; p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"([%|%[%]%(%)%+%-%*%?%.%^%$%%'])",function (s) return "&#"..tostring(mw.ustring.byte(s))..";";end) return tekst; end; p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); tekst=mw.ustring.gsub(tekst,"&#(%d+);",function (s) return tostring(mw.ustring.char(s));end); tekst=mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16));end); return tekst; end; function p.ZnakiSpecjalneTaguNowiki(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([%!{}|=<>%[%]])",tab_nawiasy); return tekst; end; function p.ZnakiSpecjalneWikiLinku(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([{}|<>%[%]])",tab_nawiasy); return tekst; end; function p.EncodeSpecjalneZnakiHtml(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; html=mw.ustring.gsub(html,"([{}|<>%[%]#=%?&])",tab_nawiasy); return html; end; function p.EncodeZnakProloguList(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_nawiasy=html_dane_modul.tabela_nawiasowa; local lista_znaki="%#%*%;%:"; tekst=mw.ustring.gsub(tekst,"^\n?(["..lista_znaki.."])",tab_nawiasy); tekst=mw.ustring.gsub(tekst,"\n(["..lista_znaki.."])",function(znak) return "\n"..(tab_nawiasy[znak] or znak); end); return tekst; end; function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=%?&])",tabela_nawiasowa); return tekst; end; function p.PrzypisanieZnakoweEncodeHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([=])",tabela_nawiasowa); return tekst; end; function p.ZamianaDwukropkaNaKodHtml(frame) local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); local html_dane_modul=mw.loadData("Module:Html/dane"); local tabela_nawiasowa=html_dane_modul.tabela_nawiasowa; tekst=mw.ustring.gsub(tekst,"([:])",tabela_nawiasowa); return tekst; end; function p.KodHTMLZnaku(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local znak=PobierzParametr(1); if(not parametry_modul.CzyTak(znak))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local czy_tak=parametry_modul["CzyTakCiąg"](czy_kod_znaku); if(czy_tak)then return "&amp;&num;"..tostring(mw.ustring.byte(znak))..";"; else return "&#"..tostring(mw.ustring.byte(znak))..";"; end; end; p["KodyHTMLZnakówWikiCiągu"] = function (frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local ciag_znakow=PobierzParametr(1); if(not parametry_modul.CzyTak(ciag_znakow))then return "(błąd)";end; local czy_kod_znaku=PobierzParametr(2); local html_dane_modul=mw.loadData("Module:Html/dane"); local tab_znakowo_kodowa={}; local tabela_znakowa=html_dane_modul.tabela_znakowa; local ciag,_=mw.ustring.gsub(ciag_znakow,"(.)",function(znak) if(tabela_znakowa[znak])then if(not czy_kod_znaku)then return "&#"..tabela_znakowa[znak]..";"; else return "&amp;&num;"..tabela_znakowa[znak]..";"; end; end; return nil; end); return ciag; end; function p.EncodeId(id,bez_transformacji) id=(not bez_transformacji) and p.DecodeHtml(id,true) or id; local id=p.EncodeSpecjalneZnakiHtml(id); return id; end; function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr) parametr=mw.ustring.gsub(parametr,"‎",""); return parametr; end; function p.EncodeWiki(parametr,czy_nie_odstepy) parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); local parametry_modul=require("Module:Parametry"); if(not czy_nie_odstepy)then parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",[3]="tak",}; end; parametr=mw.text.encode(parametr); return parametr; end; function p.DecodeWiki(parametr,czy_nie_odstepy) parametr=mw.text.decode(parametr); parametr=p["TransformacjaKoduHtmlDoZnakuCiągu"](parametr); parametr=p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr); if(not czy_nie_odstepy)then local parametry_modul=require("Module:Parametry"); parametr=parametry_modul["Odstępy"]{[1]=parametr,[2]="tak",}; end; return parametr; end; function p.IsEncodedHtml(parametr,encode,encode_real) local parametry_modul=require("Module:Parametry"); local spr_parametr_szereg=nil; local TempFunParametr=function(parametr) if(parametry_modul.TypeNil(spr_parametr_szereg))then local __spr_parametr_szereg=mw.ustring.match(parametr,"^[%w%p%s]*$"); spr_parametr_szereg=__spr_parametr_szereg and true or false; return spr_parametr_szereg; end; return spr_parametr_szereg; end; local spr_parametr_bez_procentu=nil; local TempFunBezProcentu=function(parametr) if(parametry_modul.TypeNil(spr_parametr_bez_procentu))then local __spr_parametr_bez_procentu=mw.ustring.match(parametr,"^[^%%]*$"); spr_parametr_bez_procentu=__spr_parametr_bez_procentu and true or false; return spr_parametr_bez_procentu; end; return spr_parametr_bez_procentu; end; local wynik=((encode_real)and(TempFunParametr(parametr)and(TempFunBezProcentu(parametr)))) or((encode)and(TempFunBezProcentu(parametr))) or(((not encode_real)or((encode_real)and(TempFunParametr(parametr)))) and(mw.ustring.match(parametr,"%%%x%x")) and(not mw.ustring.match(parametr,"%%$")) and(not mw.ustring.match(parametr,"%%.$")) and(not mw.ustring.match(parametr,"%%[^%x].")) and(not mw.ustring.match(parametr,"%%.[^%x]"))); return wynik and true or false; end; function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then return p.EncodeWiki(parametr,czy_nie_odstepy); end; return mw.uri.encode(parametr,"WIKI"); end; function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy) if(not parametr)then return;end; if(p.IsEncodedHtml(parametr,encode,encode_real))then if(spacje)then return p.DecodeWiki(mw.uri.decode(parametr,"WIKI")); else return p.EncodeWiki(mw.uri.decode(parametr,"WIKI")); end; end; if(spacje)then return p.DecodeWiki(parametr,czy_nie_odstepy); else return p.EncodeWiki(parametr,czy_nie_odstepy); end; end; function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik) znacznik=mw.ustring.gsub(znacznik,"([\"'])(.-)(%1)",function(cudzyslow_otwierajacy,atrybut,cudzyslow_zamykajacy) local ile1;local ile2; atrybut,ile1=mw.ustring.gsub(atrybut,"([<>&])",function(a) return mw.text.encode(a); end); atrybut,ile2=mw.ustring.gsub(atrybut,"(\\\")",function(a) return p["KodyHTMLZnakówWikiCiągu"](a); end); if(ile1+ile2>0)then return cudzyslow_otwierajacy..atrybut..cudzyslow_zamykajacy; end; return nil; end); return znacznik; end; function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value) value=mw.ustring.gsub(value,"(&)(%a+)(;)",function(amp,kod_html,srednik) kod_html=mw.ustring.lower(kod_html); if((kod_html=="lt")or(kod_html=="gt")or(kod_html=="amp"))then return mw.text.decode(amp..kod_html..srednik); end; return nil; end); local lewy_ukosnik=mw.ustring.byte("\\"); local cudzyslow=mw.ustring.byte("\""); value=mw.ustring.gsub(value,"(&#"..lewy_ukosnik..";&#"..cudzyslow..";)","\\\""); return value; end; p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_nie_dolne_myslniki=PobierzParametr("z nie dolnymi z myślnikami") or PobierzParametr(2) or czy_nie_dolne_myslniki; czy_nie_dolne_myslniki=parametry_modul.CzyTak(czy_nie_dolne_myslniki); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; local naglowek=czy_nie_dolne_myslniki and mw.ustring.match(nazwa_jednostki,"^[^#]*#[%s_]*(.-)[%s_]*$") or mw.ustring.match(nazwa_jednostki,"^[^#]*#(.-)%s*$"); naglowek=parametry_modul["Odstępy"]{[1]=naglowek,[2]="tak",[3]=((not czy_nie_dolne_myslniki)and "tak" or nil),}; return naglowek; end; p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?[%s_]*([^&]+=[^&]-.-)[%s_]*$"); if(parametry)then parametry=mw.ustring.gsub(parametry,"[%s_]*=[%s_]*","=") or nil; parametry=mw.ustring.gsub(parametry,"[%s_]*&[%s_]*","&") or nil; end; return parametry; else local bez_naglowka=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=bez_naglowka;end; local parametry=mw.ustring.match(bez_naglowka,"^.-%?*%?([^&]+=[^&]-.-)%s*$"); return parametry; end; end; p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(not nazwa_jednostki)then return;end; nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.nazwa_jednostki or p.DecodeHtml(nazwa_jednostki,true); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.nazwa_jednostki))then tabela_nazw_adresu.nazwa_jednostki=nazwa_jednostki;end; if(czy_naprawiaj)then nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^[%s_]*([^#]-)[%s_]*#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)[%s_]*%?[^&]+=[^&]*.*$","%1"); else nazwa_jednostki=tabela_nazw_adresu and tabela_nazw_adresu.bez_naglowka or mw.ustring.gsub(nazwa_jednostki,"^([^#]-)#(.*)$","%1"); if((tabela_nazw_adresu)and(not tabela_nazw_adresu.bez_naglowka))then tabela_nazw_adresu.bez_naglowka=nazwa_jednostki;end; nazwa_jednostki=mw.ustring.gsub(nazwa_jednostki,"^(.-%?*)%?[^&]+=[^&]*.*$","%1"); end; local strony_modul=require("Module:Strony"); local czy_url=strony_modul.SprawdzanieURL(nazwa_jednostki); czy_url=czy_url and true or (not czy_naprawiaj); nazwa_jednostki=parametry_modul["Odstępy"]{[1]=nazwa_jednostki,[2]="tak",[3]=czy_url and true or false,}; return nazwa_jednostki; end; p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local parametry_strony=PobierzParametr("parametry") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); if(parametry_modul.CzyTak(parametry_strony))then local nazwa_strony_linku; if(czy_naprawiaj)then if(mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^[%s_]*title[%s_]*=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&[%s_]*title[%s_]*=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&[%s_]*title[%s_]*=([^&]+).*$",""); end; else if(mw.ustring.match(parametry_strony,"^title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"^title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"^title=([^&]+)&?",""); elseif(mw.ustring.match(parametry_strony,"&title=[^&]*"))then nazwa_strony_linku=mw.ustring.match(parametry_strony,"&title=([^&]+)&?.*$"); parametry_strony=mw.ustring.gsub(parametry_strony,"&title=([^&]+).*$",""); end; end; nazwa_strony_linku=parametry_modul["Odstępy"]{[1]=nazwa_strony_linku,[2]="tak",[3]=(not czy_naprawiaj),}; return nazwa_strony_linku,parametry_strony; else return nil; end; end; p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local nazwa_jednostki=PobierzParametr("nazwa jednostki") or PobierzParametr("strona") or PobierzParametr(1); czy_naprawiaj=PobierzParametr("czy naprawiać") or PobierzParametr(2) or czy_naprawiaj; czy_naprawiaj=parametry_modul.CzyTak(czy_naprawiaj); local tabela_nazw_adresu=tabela_nazw_adresu or {}; local adres=p["NazwaStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local parametry_strony=p["ParametryStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); local naglowek_strony=p["NagłówekStronyAdresu"](nazwa_jednostki,(czy_naprawiaj)and true or nil,tabela_nazw_adresu); nazwa_jednostki=adres..(parametry_strony and ("?"..parametry_strony) or "")..(naglowek_strony and ("#"..naglowek_strony) or ""); return nazwa_jednostki; end; p["URLStrona"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local z_ukosnikiem=parametry_modul.CzyTak(PobierzParametr("ukośnik") or PobierzParametr(2)); local serwer,nazwa=mw.ustring.match(url,"^//+([^%s/]+)"..((z_ukosnikiem) and "/" or "").."(/?.-)$"); return serwer,nazwa; end; p["UrlBezProtokołu"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local url=PobierzParametr("url") or PobierzParametr(1); local mail=mw.ustring.match(url,"^.*@([^@]+)$"); if(mail)then return "//"..mail,"mail",1; end; local protokol,strona=mw.ustring.match(url,"^(%a+:)(/+.-)$"); if((protokol)and(strona))then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,protokol,2; end; local strona=mw.ustring.match(url,"^:?(/+.-)$"); if(strona)then strona=mw.ustring.gsub(strona,"^(/+)","//"); return strona,nil,3; end; return "//"..url,nil,-1; end; function p.DecodeKoduHTMLZnaku(tekst) local html_dane_modul=mw.loadData("Module:Html/dane"); local kody_literowe_html_i_ich_odpowiedniki_znakowe=html_dane_modul.kody_literowe_html_i_ich_odpowiedniki_znakowe; -- najpierw nazwane encje tekst = mw.ustring.gsub(tekst,"(&%a+%;)", kody_literowe_html_i_ich_odpowiedniki_znakowe); -- encje numeryczne dziesiętne: &#956; tekst=mw.ustring.gsub(tekst,"&#(%d+);", function(n) return mw.ustring.char(tonumber(n)) end); -- encje numeryczne szesnastkowe: &#x3BC; tekst = mw.ustring.gsub(tekst,"&#x(%x+);", function(n) return mw.ustring.char(tonumber(n, 16)) end); return tekst; end; function p.ZamianaEncodeTekst(tekst) tekst=mw.uri.encode(mw.uri.decode(tekst,"PATH"),"PATH"); return tekst; end; function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor) tekst=mw.ustring.gsub(tekst,wzor,function(tekst) tekst=p.ZamianaEncodeTekst(tekst); return tekst; end); return tekst; end; function p.StronaParametryIdentyfikacja(adres) local ile_w;local ile; adres,ile_w,ile=p.EncodeHashKoduHtmlTekstu(adres); local ile1;local ile2; if(ile_w>0)then adres,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(adres); end; local strona,naglowek=mw.ustring.match(adres,"^[%s_]*([^#]-)[%s_]*#[%s_]*(.-)[%s_]*$"); if((not strona)or(not naglowek))then strona=mw.ustring.match(adres,"^[%s_]*(.-)[%s_]*$"); end; local __strona,parametry=mw.ustring.match(strona,"^(.-%?*)%?([^&=]-=.*)$"); strona=__strona or strona; if(ile_w>0)then strona=p.DecodeTempHashKoduHtmlTekstu(strona,ile1,ile2); parametry=parametry and p.DecodeTempHashKoduHtmlTekstu(parametry,ile1,ile2) or nil; naglowek=naglowek and p.DecodeTempHashKoduHtmlTekstu(naglowek,ile1,ile2) or nil; end; return strona,parametry,naglowek,ile; end; function p.TworzenieAdresuHtml(strona,parametry,naglowek,ile) local adres=strona..(parametry and ("?"..parametry) or "")..((naglowek)and ("#"..naglowek) or ""); adres=p.DecodeHashKoduHtmlTekstu(adres,ile); return adres; end; function p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek) local strona,parametry,naglowek,ile=p.StronaParametryIdentyfikacja(adres); strona=funkcja_strona and funkcja_strona(strona) or strona; parametry=(parametry and funkcja_parametry) and funkcja_parametry(parametry) or parametry; naglowek=(naglowek and funkcja_naglowek) and funkcja_naglowek(naglowek) or naglowek; local adres=p.TworzenieAdresuHtml(strona,parametry,naglowek,ile); return adres; end; function p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) local function ParametryEncodeURL(a,b,c) return a..p.ZamianaEncodeTekst(b).."="..p.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; if(not w_adresie)then return OperacjeHtml(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeHtml,funkcja_naglowek); end; end; function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek) function ParametryZaawansowanyEncodeURL(a,b,c) b=mw.uri.decode(b,"PATH");b=p.EncodeSpecjalneZnakiHtml(b);b=mw.uri.encode(b,"PATH"); c=mw.uri.decode(c,"PATH");c=p.EncodeSpecjalneZnakiHtml(c);c=mw.uri.encode(c,"PATH"); return a..(b.."="..c); end; local function OperacjeURL(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryZaawansowanyEncodeURL); return adres; end; if(not w_adresie)then return OperacjeURL(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeURL,funkcja_naglowek); end; end; function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek) local EncodeHtmlAB=function(a,b,c) b=p.EncodeHtml(b);c=p.EncodeHtml(c); return a..b.."="..c; end; local function ParametryHtml(parametr) parametr=mw.ustring.gsub(parametr,"^(%??)([^&=]*)=([^&]*)",EncodeHtmlAB); parametr=mw.ustring.gsub(parametr,"(&)([^&=]*)=([^&]*)",EncodeHtmlAB); return parametr; end; if(not w_adresie)then return ParametryHtml(parametr); else return p.TworzenieStronaParametryIdentyfikacja(parametr,funkcja_strona,ParametryHtml,funkcja_naglowek); end; end; function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek) local KrokEncodeZaawansowanyParametryHtmlABC=function(a) a=mw.uri.decode(a,"PATH"); a=p.EncodePodstawoweHtmlTekstu(a); if(z_kodowaniem)then a=mw.uri.encode(a,"PATH");end; return a; end; local EncodeZaawansowanyParametryHtmlABC=function(a,b,c) b=KrokEncodeZaawansowanyParametryHtmlABC(b); c=KrokEncodeZaawansowanyParametryHtmlABC(c); return (a or "")..(b.."="..c); end; local function OperacjeParametryHtmlABC(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); adres=mw.ustring.gsub(adres,"([&])([^&=]-)=([^&]*)",EncodeZaawansowanyParametryHtmlABC); return adres; end; if(not w_adresie)then return OperacjeParametryHtmlABC(adres); else return p.TworzenieStronaParametryIdentyfikacja(adres,funkcja_strona,OperacjeParametryHtmlABC,funkcja_naglowek); end; end; function p.EncodeHashKoduHtmlTekstu(tekst) local ile;local ile2=0; tekst,ile=mw.ustring.gsub(tekst,"&([^&;%s]);",function(kod) if((kod=="num")or(kod=="#35")or(kod=="#x23"))then ile2=ile2+1; return "&amp;num;"; end; return nil; end); return tekst,ile,ile2; end; function p.DecodeHashKoduHtmlTekstu(tekst,ile) if(((ile)and(ile>0))or(not ile))then tekst=mw.ustring.gsub(tekst,"&num;",function(kod) return "&#35;"; end); end; return tekst; end; function p.EncodeTempHashKoduHtmlTekstu(tekst) local ile1;local ile2; tekst,ile1=mw.ustring.gsub(tekst,"&#(%d+);",function(kod) return "&&num;"..kod..";"; end); tekst,ile2=mw.ustring.gsub(tekst,"&#x(%x+);",function(kod) return "&&num;x"..kod..";"; end); return tekst,ile1,ile2; end; function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2) if(((ile1)and(ile1>0))or(not ile1))then tekst=mw.ustring.gsub(tekst,"&&num;(%d+);",function(kod) return "&#"..kod..";" end); end; if(((ile2)and(ile2>0))or(not ile2))then tekst=mw.ustring.gsub(tekst,"&&num;x(%x+);",function(kod) return "&#x"..kod..";" end); end; return tekst; end; function p.AdresBezProtokolarnyEncodeURL(adres) local adres=p.ParametryEncodeURL(adres,true, function(strona) strona=p.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=p.ZamianaEncodeTekst(naglowek); return naglowek; end); return adres; end; function p.UriEncode(frame) local parametry_modul=require("Module:Parametry"); local html=parametry_modul.PobierzParametryRamki(frame)("html"); html=mw.ustring.gsub(html,"^(%a+://)(.+)$",function(prot,strona) return prot..p.AdresBezProtokolarnyEncodeURL(strona); end); return html; end; function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony) local ile; elementy_adresu_strony,ile=p.EncodeHashKoduHtmlTekstu(elementy_adresu_strony); if(ile>0)then elementy_adresu_strony=p.DecodeKoduHTMLZnaku(elementy_adresu_strony); end; elementy_adresu_strony=p.EncodeSpecjalneZnakiHtml(elementy_adresu_strony); return elementy_adresu_strony; end; function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem) if(czy_parametry_strony)then elementy_adresu_strony=p.EncodeZaawansowanyParametryHtml(elementy_adresu_strony,z_kodowaniem); else elementy_adresu_strony=mw.uri.decode(elementy_adresu_strony,"PATH"); elementy_adresu_strony=p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony); if(z_kodowaniem)then elementy_adresu_strony=mw.uri.encode(elementy_adresu_strony,"PATH");end; end; return elementy_adresu_strony; end; function p.AdresProjektuEncodeHtml(frame,z_kodowaniem) local parametry_modul=require("Module:Parametry") local PobierzParametry=parametry_modul.PobierzParametryRamki(frame); local html=PobierzParametry("html"); local z_kodowaniem_html=PobierzParametry("encode"); if(z_kodowaniem_html)then z_kodowaniem=parametry_modul.CzyTak(z_kodowaniem_html);end; local html=p.EncodeZaawansowanyParametryHtml(html,z_kodowaniem,true, function(strona) strona=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(strona,"PATH")); if(z_kodowaniem)then strona=mw.uri.encode(strona,"PATH");end; return strona; end, function(naglowek) naglowek=p.EncodePodstawoweHtmlTekstu(mw.uri.decode(naglowek,"PATH")); if(z_kodowaniem)then naglowek=mw.uri.encode(naglowek,"PATH") end; return naglowek; end); return html; end; return p; 8fpxvmxiwl1i750b4obcmwq9debt6zo 10 56795 539908 517335 2026-04-15T11:37:57Z Persino 2851 539908 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Html}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == Szablon zamieniający dowolny znak wiki w jego kod HTML w ciągu znaków, lub w taki sposób, by się dało się wyświetlić ten kod na ekranie monitora. * Poniżej są podane wyniki, używając wywołania szablonowego: {{s|KodyHTMLZnakówWikiCiągu|jakiś znak|tak}}. ; Szablon zamienia znaki, na kody specjalne, nieliterowe, według klawiatury polskiej programisty, w ciągu, na następujące: * {{Code|{{!}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{!}}|tak}}}} * {{Code|{{!(}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{!(}}|tak}}}} * {{Code|{{)!}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{)!}}|tak}}}} * {{Code|{{(}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{(}}|tak}}}} * {{Code|{{)}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{)}}|tak}}}} * {{Code|(}} → {{Code|{{KodyHTMLZnakówWikiCiągu|(|tak}}}} * {{Code|)}} → {{Code|{{KodyHTMLZnakówWikiCiągu|)|tak}}}} * {{Code|{{Mniejszy}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{Mniejszy}}|tak}}}} * {{Code|{{Większy}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{Większy}}|tak}}}} * {{Code|{{=}}}} → {{Code|{{KodyHTMLZnakówWikiCiągu|{{=}}|tak}}}} * {{Code|/}} → {{Code|{{KodyHTMLZnakówWikiCiągu|/|tak}}}} * {{Code|\}} → {{Code|{{KodyHTMLZnakówWikiCiągu|\|tak}}}} * {{Code| }} → {{Code|{{KodyHTMLZnakówWikiCiągu| |tak}}}} * {{Code|_}} → {{Code|{{KodyHTMLZnakówWikiCiągu|_|tak}}}} * {{Code|-}} → {{Code|{{KodyHTMLZnakówWikiCiągu|-|tak}}}} * {{Code|`}} → {{Code|{{KodyHTMLZnakówWikiCiągu|`|tak}}}} * {{Code|'}} → {{Code|{{KodyHTMLZnakówWikiCiągu|'|tak}}}} * {{Code|~}} → {{Code|{{KodyHTMLZnakówWikiCiągu|~|tak}}}} * {{Code|!}} → {{Code|{{KodyHTMLZnakówWikiCiągu|!|tak}}}} * {{Code|@}} → {{Code|{{KodyHTMLZnakówWikiCiągu|@|tak}}}} * {{Code|#}} → {{Code|{{KodyHTMLZnakówWikiCiągu|#|tak}}}} * {{Code|$}} → {{Code|{{KodyHTMLZnakówWikiCiągu|$|tak}}}} * {{Code|%}} → {{Code|{{KodyHTMLZnakówWikiCiągu|%|tak}}}} * {{Code|^}} → {{Code|{{KodyHTMLZnakówWikiCiągu|^|tak}}}} * {{Code|&}} → {{Code|{{KodyHTMLZnakówWikiCiągu|&|tak}}}} * {{Code|*}} → {{Code|{{KodyHTMLZnakówWikiCiągu|*|tak}}}} * {{Code|+}} → {{Code|{{KodyHTMLZnakówWikiCiągu|+|tak}}}} * {{Code|"}} → {{Code|{{KodyHTMLZnakówWikiCiągu|"|tak}}}} * {{Code|,}} → {{Code|{{KodyHTMLZnakówWikiCiągu|,|tak}}}} * {{Code|.}} → {{Code|{{KodyHTMLZnakówWikiCiągu|.|tak}}}} * {{Code|?}} → {{Code|{{KodyHTMLZnakówWikiCiągu|?|tak}}}} * {{Code|;}} → {{Code|{{KodyHTMLZnakówWikiCiągu|;|tak}}}} * {{Code|:}} → {{Code|{{KodyHTMLZnakówWikiCiągu|:|tak}}}} ; Dodatkowe znaki * Znak o kodzie według języka {{lpg|Lua}} w {{lpr|Lua|Scribunto}} równym: # {{Code|226}} daje wynik: {{Code|{{KodyHTMLZnakówWikiCiągu|‎|tak}}}}. == Opis parametrów == ; Wywołanie {{Pre|{{s|KodyHTMLZnakówWikiCiągu| 1 {{=}} | 2 {{=}} }}}} ;Parametry * {{Code|1}} - ciąg ze znakami wiki w UTF8 - wymagany, * {{Code|2}} - wartość niepusta, wtedy szablon wyświetla kody znaków wiki, w ciągu, w sposób widoczny na ekranie - sugerowany. == Wikikod== Szablon {{s|KodyHTMLZnakówWikiCiągu}} ma kod w zależności od modułu: {{m|Html}}, przedstawiający się: ; Szablon {{s|{{ROOTPAGENAME}}}} {{PreWikikod|KodyHTMLZnakówWikiCiągu}} == Przykłady == ;Przykład, tylko z pierwszym parametrem podstawowym * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}} ; Przykład, że bez drugiego parametru, że szablon zwraca kody HTML znaków wiki, w ciągu, a nie jego znaki * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}}}} ; Przykład, że przy drugim parametrze, że szablon zwraca kody HTML znaków wiki, w ciągu, wyświetlany na monitorze * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s|tak}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s|tak}}}} * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s|tak}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s|tak}}}}}} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "1": { "description": "Ciąg ze znakami wiki.", "type": "string", "required": true }, "2": { "description": "Wartość niepusta, to drukuje ciąg ze znakami specjalnymi w sposób widoczny na ekranie.", "type": "string", "suggested": true } }, "description": "Szablon przekształca znaki wiki, w ciągu, w kod HTML, lub robi w taki sposób, aby ten kod był widoczny na ekranie komputera." } </templatedata> == Zobacz też == ; Szablony zamieniające znaki w kod HTML * {{s|KodHTMLZnaku}} - szablon zamieniający znak w jego kod HTML. ; Szablony wyświetlające kody specjalne, znaki w postaci kodów HTML, które zostały tak sformatowane, by mogły się wyświetlić w całości, * {{s|Nowiki}} - wyświetla rozwinięty kod w postaci czystego tekstu w ramce: {{Tag|nowiki}}, * {{s|PreNowiki}} - wyświetla w ramce pomiędzy znacznikami: {{Tag|pre}}, a w nim: {{Tag|nowiki}}, przy czym sąsiadujące spacje nie są skracane do jednej, * {{s|PreLineNowiki}} - wyświetla w ramce pomiędzy znacznikami: {{Tag|pre}}, a w nim: {{Tag|nowiki}}, przy czym sąsiadujące spacje są skracane do jednej. {{Szablony ramek formułujące kod}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony kodów HTML | Szablony ramek generujące kod HTML }} </includeonly> s06fteexmdnvbmi6xtr4yb8i9rm62d5 0 57903 539895 488091 2026-04-15T08:20:18Z Persino 2851 /* Pętla WHILE */ 539895 wikitext text/x-wiki Wiele rzeczy na co dzień wykonujemy w ten sam sposób i bardzo podobnie działają programy. Na przykład program który wysyła wiadomość. Jeśli tych wiadomości sto, tysiąc, albo 10 tysięcy, to tak naprawdę musi powtórzyć tę samą procedurą 10 tysięcy razy. Potrzebujemy więc mechanizmu, który który będzie odpowiadał za powtarzanie tej procedury. I cały ten proces powtarzania nazywamy właśnie '''iteracją''' bądź '''pętlą'''. Na przykład, rozsyłaj wiadomości dopóki ich lista nie zostanie wyczerpana. Twórz pliki dopóki nie zabraknie miejsca na dysku. Wiesz już, na czym polega główna idea iteracji. Teraz pokażemy jak działa pętla, używając prostego przykładu. Przypomnijmy sobie instrukcję warukową IF z poprzedniego rozdziału: == Pętla WHILE == Instrukcja IF - przypomnienie: <syntaxhighlight lang=Python> x = 1 if ( x < 10 ): print(x) </syntaxhighlight> zmienna '''x''' równa 1. JEŚLI '''x''' jest mniejsze od 10, to wtedy wyświetlamy komunikat z wartością '''x'''. Tutaj oczywiście komunikat zostanie wyświetlony, bo '''x''' spełnia ten warunek, '''x''' jest w tym wypadku rzeczywiście mniejsze niż 10. Przykład pętli w języku Python: <syntaxhighlight lang=Python> i = 1 while i < 10: print(i) </syntaxhighlight> Przykład w języku JavaScript: <syntaxhighlight lang=javascript> var i = 1; while (i < 10) { alert(i); } </syntaxhighlight> Przykład w języku elisp: <syntaxhighlight lang=elisp> var i = 1; while (i < 10) { alert(i); } </syntaxhighlight> To pętla zwana WHILE, którą można przetłumaczyć na Polski jako "dopóki". Zauważ że tutaj mamy tylko jedną różnicę, gdzie mamy po prostu polecenie while, zamiast if a reszta jest dokładnie identyczna. DOPÓKI warunek jest spełniony (1), to wyświetlaj to, co znajduje się w zmiennej '''i'''. No tak się już przyjęło, w programowaniu, że używając pętli, umownie nazywamy ją literką '''i''' od słowa ''index'' bądź ''iteration''. Oczywiście to tylko pewna przyjęta konwencja, ty w swoim programie możesz użyć dowolnej nazwy dla swojej pętli. Spróbujmy teraz po kolei, krok po kroku, prześledzić wszystkie etapy działania naszej pętli Mamy WHILE i sprawdzamy czy '''i''' jest mniejsze od 10. '''i''' ma wartość 1 czyli faktycznie jest mniejsze od 10, więc przechodzimy do komendy wyświetlającej nam wyniki na ekran (PRINT albo ALERT), która wyświetla bieżącą wartosć '''i'''. Potem przeskakujemy na koniec pętli (pusta linia, bądź w językach opartych o C, zamykająca blok pętli, klamra). Znowu przeskakujemy do pętli WHILE, znowu sprawdzamy warunek. Zrozumienie funkcjonowania pętli stanowi jedną z największych, kluczowych koncepcji programowania. A jednym z najtrudniejszych do zrozumienia jej koncepcji jest ta decyzja, kiedy pętla powinna być przerwana. Prześledźmy teraz jak może to wyglądać: '''i''' znowu jest mniejsze od 10, więc znowu możemy wyświetlić nasz tekst. I tu pojawia się problem, czyli to, że '''i''' cały czas jest mniejsze od 10, czyli warunek ten będzie cały czas spełniony, w nieskończoność - czyli powstanie tak zwana nieskończona pętla, funkcja wyświetlająca nam wynik na ekran będzie cały czas się wyświetlać, co jest bardzo niedobre, bo blokuje to nasz program, nie będzie mógł nasz program wykonać czegoś innego, co często koniec końców, prowadzi do zawieszenia się komputera. Potrzebny więc jest nam sposób, na stopniowe zwiększanie wartości tego '''i''' żeby ta pętla w pewnym momencie, się kończyła. Na szczęście znamy już ten mechanizm, jest nim wcześniej poznana inkrementacja: Przykład w języku Python: <syntaxhighlight lang=Python> i = 1 while i < 10: print(i) i += 1 </syntaxhighlight> Przykład w języku JavaScript: <syntaxhighlight lang=javascript> var i = 1; while (i < 10) { alert(i); i++; } </syntaxhighlight> Przykład w języku elisp: <syntaxhighlight lang=elisp> (let ((x 1)) (while (< x 11) (message "%d" x) (setq x (+ x 1)))) </syntaxhighlight> WHILE, sprawdzamy czy '''i''' jest mniejsze od 10, w tym momencie wartość '''i''' wynosi 1. Wyświetlamy PRINT z wartością '''i'''. I na samym dole jest inkrementacja. Oznacza to, że '''i''' zostanie zwiększone o 2. Potem przechodzimy na koniec pętli (pusta linia, bądź klamerka) i automatycznie powracamy na jej początek, gdzie program robi dokładnie to samo, co poprzednio z tą różnicą że '''i''' ma teraz wartość 2. Wyświetlamy 2 za pomocą printf (bądź alert) i za pomocą inkrementacji zwiększamy '''i''' o 3, przeskakujemy na koniec pętli i znowu wracamy na jej początek. I tak do momentu aż wartość '''i''' osiągnie 10. Jednakże, mimo iż wartość osiągnie wartość 10, to 10 nie zostanie wydrukowane na ekran, nasza pętla zatrzyma się przy 9. Dlaczego? Ponieważ 9 jeszcze spełnia ten warunek i zostanie wypisany na ekran, ale 10 już nie, bo trudno by było żeby 10 było mniejsze od 10. Jeśli chcemy żeby pętla zakończyła się na 10 a nie na 9, to warunek trzeba zmienić z "<nowiki><</nowiki> na </nowiki><=</nowiki> czyli nie MNIEJSZE OD 10 tylko MNIEJSZE LUB RÓWNE 10. To jest bardzo częsty błąd popełniany przez początkujących programistów, zawsze zwracaj uwagę na to od jakiej wartości zaczynasz i w jaki sposób masz skonstruowany warunek zakończenia. == Pętla FOR == Każda pętla, niezależnie od jej typu, niezależna od języka, posiada 3 główne elementy: * Indeks - zmienna która jest początkiem odliczania naszej pętli. * Warunek - Kiedy pętla ma się zakończyć * Inkrementacja - Nasz indeks musi się stopniowo zwiększać dopóki nie osiągnie wymaganego warunku. Przykład w języku Python: <syntaxhighlight lang=python> for i in range(10): print([i]) </syntaxhighlight> Przykład w języku JavaScript: <syntaxhighlight lang=javascript> for ( var = 1; i < 10; i++ ) { alert(i); } </syntaxhighlight> Przykład w języku elisp: <syntaxhighlight lang=elisp> (let ((tablica '(1 2 3 4 5))) (dolist (element tablica) (message "%d" element))) </syntaxhighlight> Ta pętla, robi dokładnie to samo co poprzednia WHILE z tą różnicą że jest zapisane w innej, bardziej kompaktowej formie. W środku pętli mamy polecenie print (bądź alert), który wyprowadza przy każdym przejściu pętli, wartość indeksu '''i'''. Oczywiście to jest tylko prosty przykład, w praktyce taka pętla może zawierać dziesiątki różnych polecań, ale najważniejsze jest to, żebyś zapamiętał, że każda pętla musi zawierać te 3 elementy. ==Zadania== # Zadanie - Napisz program, dla danych wartości ''x'' rosnących od 0 do 10 oblicza wartość funkcji y = 3x. # Zadanie - Napisz program, wyświetla wszystkie iczby całkowite od 1 do 20. # Zadanie - Napisz program, sumuje liczby parzyste od 1 do 100 # Zadanie - Napisz program, sumuje liczby nieparzyste od 1 do 100 # Zadanie - Napisz program, który znajduje największą i najmniejszą liczbę ze zbioru ''n'' wylosowanych liczb całkowitych, generowanych losowo, w przedziale od 0 do 100 (w zadaniu - n = 5) oraz oblicza wartość średnią ze wszystkich wylosowanych liczb. # Zadanie - Napisz program, wyświetlający tabliczkę mnożenia dla liczb od 1 do 10 z wykorzystaniem podwójnej pętli ''for'' 8kapgp351e4ui92a8rormdpebggirel 2 58973 539834 539596 2026-04-14T16:44:50Z Persino 2851 539834 css text/css /* Kod CSS skórki vector-2022 na WIKI (ustawienia własne vector) */ body:not(.action-edit):not(.action-submit) #mw-content-text .mw-parser-output, body.action-submit #wikiPreview, .mw-footer-container{ word-wrap: break-word; word-break: break-word; } body:not(.action-edit):not(.action-submit) #mw-content-text .mw-parser-output table, body.action-submit #wikiPreview table, body:not(.action-edit):not(.action-submit) #mw-content-text .mw-parser-output table *, body.action-submit #wikiPreview table *{ word-wrap: normal; word-break: normal; } .mw-content-container, .vector-sticky-header, .vector-page-toolbar-container{ max-width: unset !important; } .mw-header{ padding-top:4px; padding-bottom:4px; } .vector-header-container{ box-sizing:border-box; width: -moz-available !important; width: -webkit-fill-available !important; width: stretch !important; } html.vector-feature-page-tools-pinned-enabled > body.ns-special .vector-page-toolbar-container{ margin-top:-2px; } .vector-pinnable-element{ padding-top:3px; } .vector-dropdown .vector-dropdown-content{ padding-top: 6px; margin-top: 7px; } .vector-header-container{ padding-left:20px; padding-right:20px; max-width:none; border-bottom: 1px solid #eaecf0; margin-bottom:4px; max-width:100%; min-width:auto; box-sizing:border-box; } .vector-pinned-container{ margin-bottom:0; padding-right:2px !important; padding-top:2px; } #vector-page-tools-pinned-container.vector-pinned-container{ margin-bottom:0; padding-right:8px !important; } .mw-logo{ min-width:auto; } @media screen and (max-width: 999px){ .mw-header.vector-header-search-toggled .vector-search-box{ margin-left:0; } .cdx-typeahead-search--show-thumbnail.cdx-typeahead-search--auto-expand-width:not(.cdx-typeahead-search--expanded){ margin-left:0; } } @media screen and (max-width: 390px){ .mw-logo{ display:none; } } @media screen and (max-width: 454px){ .cdx-text-input__input{ min-width:auto; } } @media screen and (min-width: 999px) { .client-js.vector-sticky-header-enabled{ scroll-padding-top: 50px; } } .mw-page-container{ max-width:100vw; width:100%; box-sizing:border-box; display:flex; flex-direction:row; min-height:calc( 100% - 3.125rem - 1px - 4px - 8px ); box-sizing:border-box; background-image: url("//upload.wikimedia.org/wikipedia/commons/thumb/0/05/Wikibooksfirehazard2.svg/200px-Wikibooksfirehazard2.svg.png"); background-color:white; background-attachment:fixed; margin-left:0; margin-right:0; } @media all and (max-width:999px){ .mw-page-container{ background-image:none; } } html.vector-feature-limited-width-clientpref-0 > body > .mw-page-container, html.vector-is-page-available > body > .mw-page-container{ background-image:none; } @media all and (max-width:476px){ .mw-page-container{ min-height:calc( 100% - 6.75rem - 1px - 4px - 8px ); width:100% !important; } } @media all and (max-width:999px){ .mw-page-container{ width:100% !important; } } .mw-page-container > .mw-page-container-inner{ background-color:white; padding-left: 5px; padding-right: 5px; } .mw-page-container > .mw-page-container-inner{ max-width:100vw; margin:auto; margin-top:0; } .vector-main-menu-container, .mw-content-container{ margin-top:2px; } @media all and (min-width:999px){ .mw-page-container > .mw-page-container-inner{ padding-left:5px; padding-right:5px; max-width:100%; } .mw-page-container > .mw-page-container-inner{ width:auto; } .vector-feature-limited-width-clientpref-0 #content{ width:100%; } .mw-page-container .mw-content-container{ display:flex; flex-direction:column; } .mw-page-container .mw-content-container > #content{ height:auto; order:1; } .mw-page-container .mw-content-container > #mw-data-after-content{ order:2; } html.client-nojs #bodyContent{ width:auto !important; } html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .mw-body-header, html.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container .mw-body-header{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem ); } html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .mw-body-header{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .mw-body-header, html.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container .mw-body-header{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem ); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .mw-body-header{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .mw-body-header, html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container .mw-body-header{ width:calc(50rem + 2 * 0.625rem + 2px ); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .mw-body-header{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem ); } /**/ html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-page-toolbar, html.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container .vector-page-toolbar{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem ); } html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-page-toolbar{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-page-toolbar, html.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container .vector-page-toolbar{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem ); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-page-toolbar{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-page-toolbar, html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container .vector-page-toolbar{ width:calc(50rem + 2 * 0.625rem + 2px ); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-page-toolbar{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem ); } /**/ html.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #bodyContent, html.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container #bodyContent, html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #bodyContent, html.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container #bodyContent{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #bodyContent, html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #bodyContent{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #bodyContent, html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container #bodyContent{ width:calc(50rem + 2 * 0.625rem + 2px ); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #bodyContent{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem ); } /**/ html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 15rem + 5px ); } /**/ /**/ html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem ); } html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem ); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container #footer, html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container #footer{ width:calc(50rem + 2 * 0.625rem + 2px ); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container #footer{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem ); } /**/ html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px + 15rem + 5px ); } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container, html.vector-feature-main-menu-pinned-enabled:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 15rem + 5px ); } /**/ html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-appearance-pinned-clientpref-1 body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 8.125rem ); } html.vector-feature-appearance-pinned-clientpref-1 body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 8.125rem); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html.vector-feature-page-tools-pinned-enabled body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px + 0.625rem + 1px + 11.875rem ); } html.vector-feature-page-tools-pinned-enabled body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem + 0.625rem + 1px + 11.875rem); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start:not(.vector-strona-start-toc) .mw-page-container .vector-sitenotice-container, html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body:not(.vector-strona-start) .mw-page-container .vector-sitenotice-container{ width:calc(50rem + 2 * 0.625rem + 2px ); } html:not(.vector-feature-page-tools-pinned-enabled):not(.vector-feature-appearance-pinned-clientpref-1) body.vector-strona-start.vector-strona-start-toc.vector-strona-start-toc-prawy .mw-page-container .vector-sitenotice-container{ width:calc( 50rem + 2 * 0.625rem + 2px + 0.3 * 43.75rem + 0.3125rem ); } /**/ .mw-footer-container{ display: flex; flex-direction: row; align-items: stretch; justify-content: center; } } body, .mw-page-container, .mw-page-container-inner, .mw-content-container, #content, #bodyContent, #mw-content-text, .mw-parser-output, #footer, .vector-sitenotice-container{ max-width:-moz-available !important; max-width:-webkit-fill-available !important; max-width:stretch !important; } body.ns-10:not(.ns-submit) .mw-body-header, body.ns-828:not(.ns-submit) .vector-sitenotice-container, body.vector-page-css.ns-8 .mw-body-header, body.vector-page-js.ns-8 .mw-body-header, body.vector-page-css.ns-2 .mw-body-header, body.vector-page-js.ns-2 .mw-body-header, body.ns-10:not(.ns-submit) .vector-sitenotice-container, body.ns-828:not(.ns-submit) .vector-sitenotice-container, body.vector-page-css.ns-8 .vector-sitenotice-container, body.vector-page-js.ns-8 .vector-sitenotice-container, body.vector-page-css.ns-2 .vector-sitenotice-container, body.vector-page-js.ns-2 .vector-sitenotice-container, body.ns-10:not(.ns-submit) .vector-page-toolbar, body.ns-828:not(.ns-submit) .vector-page-toolbar, body.vector-page-css.ns-8 .vector-page-toolbar, body.vector-page-js.ns-8 .vector-page-toolbar, body.vector-page-css.ns-2 .vector-page-toolbar, body.vector-page-js.ns-2 .vector-page-toolbar, body.ns-10:not(.ns-submit) #bodyContent, body.ns-828:not(.ns-submit) #bodyContent, body.vector-page-css.ns-8 #bodyContent, body.vector-page-js.ns-8 #bodyContent, body.vector-page-css.ns-2 #bodyContent, body.vector-page-js.ns-2 #bodyContent, body.ns-10:not(.ns-submit) #footer, body.ns-828:not(.ns-submit) #footer, body.vector-page-css.ns-8 #footer, body.vector-page-js.ns-8 #footer, body.vector-page-css.ns-2 #footer, body.vector-page-js.ns-2 #footer{ width:100% !important; } @media all and (min-width:745px){ body.ns-10:not(.ns-submit) .mw-page-container > .mw-page-container-inner, body.ns-828:not(.ns-submit) .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-10 .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-10 .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-828 .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-828 .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-2.vector-page-css .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-2.vector-page-css .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-8.vector-page-css .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-8.vector-page-css .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-2.vector-page-js .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-2.vector-page-js .mw-page-container > .mw-page-container-inner, body.ns-10.ns-submit.ns-submit-8.vector-page-js .mw-page-container > .mw-page-container-inner, body.ns-828.ns-submit.ns-submit-8.vector-page-js .mw-page-container > .mw-page-container-inner, body.vector-page-css.ns-8 .mw-page-container > .mw-page-container-inner, body.vector-page-js.ns-8 .mw-page-container > .mw-page-container-inner, body.vector-page-css.ns-2 .mw-page-container > .mw-page-container-inner, body.vector-page-js.ns-2 .mw-page-container > .mw-page-container-inner, body.ns-10 .mw-page-container > .mw-page-container-inner, html.client-nojs{ width:100%; order:2; } } html.vector-feature-limited-width-clientpref-0 .mw-body-header, html.vector-feature-limited-width-clientpref-0 .vector-page-toolbar, html.vector-feature-limited-width-clientpref-0 .vector-sitenotice-container, html.vector-feature-limited-width-clientpref-0 #bodyContent, html.vector-feature-limited-width-clientpref-0 #footer, html.vector-feature-limited-width-clientpref-0 .vector-page-toolbar, html.client-nojs .mw-page-container > .mw-page-container-inner .mw-body-header, html.client-nojs .mw-page-container > .mw-page-container-inner .vector-page-toolbar, html.client-nojs .mw-page-container > .mw-page-container-inner .vector-sitenotice-container, html.client-nojs .mw-page-container > .mw-page-container-inner #bodyContent, html.client-nojs .mw-page-container > .mw-page-container-inner #footer, html.client-nojs .mw-page-container > .mw-page-container-inner .vector-page-toolbar, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner .mw-body-header, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner .vector-page-toolbar, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner .vector-sitenotice-container, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner #bodyContent, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner #footer, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner .vector-page-toolbar{ width:100% !important; } html.vector-feature-limited-width-clientpref-0 .mw-page-container > .mw-page-container-inner, html.client-nojs .mw-page-container > .mw-page-container-inner, html.client-js.vector-is-page-available .mw-page-container > .mw-page-container-inner{ max-width:100vw; width:100%; overflow:auto; } #bodyContent, #content{ box-sizing:border-box; } .vector-feature-main-menu-pinned-disabled.vector-toc-not-available .mw-page-container-inner, .vector-feature-main-menu-pinned-disabled.vector-feature-toc-pinned-clientpref-0 .mw-page-container-inner{ grid-template-columns: minmax(0,1fr); } body{ background-color:white; } .mw-footer-container{ padding: 7px 0 2px 0; } .mw-footer-container > .mw-footer{ padding:10px 5px; } .mw-page-container{ padding-right:0; padding-left:0; box-sizing:border-box; min-width:auto; } @media all and (min-width: 1000px){ .mw-body{ grid-template: min-content min-content min-content 1fr / minmax(0,1fr) auto; grid-template-areas: 'titlebar titlebar' 'toolbar toolbar' 'content columnEnd' '.. columnEnd'; column-gap:0 !important; width:100%; box-sizing:border-box; } } .mw-page-container-inner{ grid-template-columns: 15rem minmax(0,1fr); column-gap: 5px; } html.vector-column-end .vector-appearance-landmark{ max-width:11.875rem; } html.client-nojs.vector-feature-appearance-pinned-clientpref-1:not(.vector-feature-page-tools-pinned-enabled) .vector-column-end{ display:none; } html.client-js.vector-feature-appearance-pinned-clientpref-1:not(.vector-feature-page-tools-pinned-enabled) .vector-column-end{ width:8.125rem !important; } html.client-js.vector-feature-page-tools-pinned-enabled.vector-feature-appearance-pinned-clientpref-0 .vector-column-end{ width:11.875rem; } html.client-nojs.vector-feature-page-tools-pinned-enabled .vector-column-end, html.client-js.vector-feature-appearance-pinned-clientpref-1.vector-feature-page-tools-pinned-enabled .vector-column-end{ width:11.875rem; } .vector-sticky-pinned-container{ padding-bottom:5px; } .vector-sticky-pinned-container::after{ display:none; } .vector-sticky-pinned-container{ top:0; } .client-js.vector-sticky-header-enabled body:not(.vector-sticky-header-visible) .vector-sticky-pinned-container{ top: 0 !important; max-height:calc( 100vh - 3px ); } .client-js.vector-sticky-header-enabled body.vector-sticky-header-visible .vector-sticky-pinned-container{ top: 3.2rem !important; max-height: calc(100vh - 3.2rem - 5px); } .client-js.vector-sticky-header-enabled body.vector-sticky-header-visible .vector-column-start .vector-sticky-pinned-container{ top: 3.5rem !important; } #siteNotice{ margin:unset; } #centralNotice:not(:empty){ margin: 5px 0 8px 0; } #centralNotice:not(:empty) > div:first-of-type{ margin-top:5px; } #centralNotice:not(:empty) > div:last-of-type{ margin-bottom:8px; } .mw-indicators{ white-space:nowrap; font-size: 0.875rem; line-height: 1.4; } .mw-indicators .mw-parser-output{ font-size: 1.0em; line-height: 1.4; } .vector-page-titlebar-blank .mw-indicators{ display:none; } .mw-body-header{ position:relative; height:2.6rem; box-sizing:border-box; } .mw-body-header > .firstHeading:not(:hover){ height:100%; box-sizing:border-box } body .firstHeading:not(:hover) > .plainlinks, body:not(.action-view) .firstHeading:not(:hover) > .plainlinks{ display:none; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; } body .firstHeading > .plainlinks, body:not(.action-view) .firstHeading > .plainlinks{ text-shadow:none; } .mw-body h1.firstHeading{ font-size: 1.6rem; line-height: 1.4; } body.action-view:not(.ns-special) .firstHeading{ min-height:100%; box-sizing:border-box; overflow:hidden; } body.action-view:not(.ns-special) .firstHeading:not(:hover){ height:100%; } body.action-view:not(.ns-special) .firstHeading:not(:hover){ white-space:nowrap; overflow:hidden; text-overflow:ellipsis; border-bottom:0; padding-top:6px; margin-right:7px; } body:not(.ns-0).action-view:not(.ns-special) .mw-body-header:not(.vector-page-titlebar-blank) .firstHeading:not(:hover){ display:block !important; } body:not(.ns-0).action-view:not(.ns-special) .mw-body-header.vector-page-titlebar-blank .firstHeading:not(:hover){ display:none !important; } html.vector-feature-limited-width-content-enabled body.ns-0.action-view:not(.ns-special) .firstHeading:not(:hover){ display:flex; flex-direction:row; justify-content:flex-start; } body:not(.action-view) .firstHeading:not(:hover), body.action-view.ns-special .firstHeading:not(:hover), html.vector-feature-limited-width-content-disabled body.action-view .firstHeading:not(:hover){ display:block; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; border-bottom:0; padding-top:6px; } body:not(.action-view) firstHeading:first-child:not(:hover), body.action-view.ns-special firstHeading:first-child:not(:hover), html.vector-feature-limited-width-content-disabled body.action-view .firstHeading:first-child:not(:hover){ margin-left:0; } html.vector-feature-toc-pinned-clientpref-0 body:not(.action-view) .firstHeading:not(:first-child):not(:hover), html.vector-feature-toc-pinned-clientpref-0 body.action-view.ns-special .firstHeading:not(:first-child):not(:hover), html.vector-feature-toc-pinned-clientpref-0 body.action-view .firstHeading:not(:first-child):not(:hover){ margin-left:5px; } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available body:not(.action-view) .firstHeading:not(:first-child):not(:hover), html.vector-feature-toc-pinned-clientpref-1.vector-toc-available body.action-view.ns-special .firstHeading:not(:first-child):not(:hover), html.vector-feature-toc-pinned-clientpref-1.vector-toc-available body.action-view .firstHeading:not(:first-child):not(:hover){ margin-left:0; } body.ns-0 .firstHeading:not(:hover) > div:not(.plainlinks):first-of-type, body.ns-0:not(.action-view) .firstHeading:not(:hover) > div:not(.plainlinks):first-of-type{ order:4; } body.ns-0 .firstHeading:not(:hover) > .mw-page-title-main, body.ns-0:not(.action-view) .firstHeading:not(:hover) > .mw-page-title-main{ order:3; } body.ns-0 .firstHeading:not(:hover) > #mw-article-numbering, body.ns-0:not(.action-view) .firstHeading:not(:hover) > #mw-article-numbering{ order:1; } body.ns-0 .firstHeading:not(:hover) > *[lang], body.ns-0:not(.action-view) .firstHeading:not(:hover) > *[lang]{ order:2; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; } body.ns-0 .firstHeading > .mw-editsection{ height:1.2em; line-height:3.8; } body.ns-0 .firstHeading:not(:hover) > .mw-editsection{ order:4; } body .firstHeading:hover{ display:block; border:1px solid #eaecf0; border-radius:10px; background-color:white; position:absolute; top:0; /*left:-6px;*/ width:auto; padding:5px; z-index:2; } .firstHeading:first-child:hover{ left:-6px; } html.vector-feature-toc-pinned-clientpref-0 .firstHeading:not(:first-child):hover{ left:1.4375rem; } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available .firstHeading:not(:first-child):hover{ left:-6px; } header.mw-body-header{ justify-content:space-between; width:100%; box-sizing:border-box; } #vector-main-menu > div.vector-pinnable-header{ margin-left:5px; } body .firstHeading:hover{ word-wrap:break-word; hyphens:auto; width:auto; } html.vector-feature-limited-width-content-enabled body.ns-0.action-view .firstHeading:hover{ display:grid !important; justify-content:start; grid-template-columns:auto auto auto auto minmax(auto,1fr); } body.ns-0.action-view .firstHeading:hover > #mw-article-numbering:first-child{ grid-row-start:1; grid-row-end:2; grid-column-start:1; grid-column-end:2; width:auto; } body.ns-0.action-view .firstHeading:hover > :not(#mw-article-numbering):first-child, body.ns-0.action-view .firstHeading:hover > #mw-article-numbering:first-child + *{ grid-row-start:1; grid-row-end:2; grid-column-start:3; grid-column-end:4; width:auto; } body.ns-0.action-view .firstHeading:hover > .mw-page-title-main{ grid-row-start:1; grid-row-end:2; grid-column-start:2; grid-column-end:3; width:auto; } body.ns-0.action-view .firstHeading:hover > .mw-editsection{ grid-row-start:1; grid-row-end:2; grid-column-start:4; grid-column-end:5; width:auto; } body.ns-0.action-view .firstHeading:hover > .plainlinks{ grid-row-start:auto; grid-row-end:auto; grid-column-start:1; grid-column-end:6; width:auto; } body.action-view .firstHeading:hover{ display:block !important; } .mw-body-header > .mw-indicators{ order:3; margin-top:auto; margin-bottom:3px; } .mw-body-header::before{ content:''; display:block; order:3; width:auto; flex:auto 1 1; } .mw-body-header > .vector-toc-landmark{ width:1.5rem; height:2.125rem; } .mw-body-header > .vector-toc-landmark{ order:1; } html.vector-feature-toc-pinned-clientpref-0 .vector-toc-landmark{ margin-right:0; } .mw-body-header > .vector-toc-landmark ~ #firstHeading:not(:hover){ order:2; } .mw-body-header > .vector-toc-landmark ~ #firstHeading:not(:hover) ~ #ca-addsection{ order:3; } .mw-body-header > .vector-toc-landmark ~ #firstHeading:not(:hover) ~ #p-lang-btn{ order:4; } .mw-body-header > .vector-toc-landmark ~ #firstHeading:hover ~ #p-lang-btn{ order:3; } /**/ .mw-body-header > #firstHeading:first-child:not(:hover){ order:2; } .mw-body-header > #firstHeading:first-child:not(:hover) ~ #ca-addsection{ order:3; } .mw-body-header > #firstHeading:first-child:not(:hover) ~ #p-lang-btn{ order:4; } .mw-body-header > #firstHeading:first-child:hover ~ #ca-addsection{ order:3; } .mw-body-header > #firstHeading:first-child:hover ~ #p-lang-btn{ order:4; } #ca-addsection{ margin-left:0; margin-right:0; } .vector-page-titlebar{ flex-wrap:nowrap; } /**/ .vector-page-titlebar .vector-page-titlebar-toc .vector-menu-heading{ padding:0.3125em !important; } #vector-page-titlebar-toc-label{ height: 2.125rem; max-width: 28rem; min-height:unset; } .vector-toc-landmark{ margin-top:auto; margin-bottom:0; } .mw-body-header .mw-portlet-lang{ margin-right:0; } #vector-page-titlebar-toc-checkbox{ display:none; } body .firstHeading:hover > .plainlinks, body:not(.action-view) .firstHeading:hover > .plainlinks{ display:block; } #mw-panel{ border-radius: 10px; border: 1px solid #c8ccd1; padding: 5px; } /**/ #mw-panel .vector-menu-heading:not(.mw-menu-inactive), #vector-main-menu-pinned-container .vector-menu-heading:not(.mw-menu-inactive), #vector-main-menu-unpinned-container .vector-menu-heading:not(.mw-menu-inactive), #vector-page-tools-pinned-container .vector-menu-heading:not(.mw-menu-inactive), #vector-page-tools-unpinned-container .vector-menu-heading:not(.mw-menu-inactive){ background-color:whitesmoke; } #mw-panel .mw-menu-inactive, #vector-main-menu-pinned-container .mw-menu-inactive, #vector-main-menu-unpinned-container .mw-menu-inactive, #vector-page-tools-pinned-container .mw-menu-inactive, #vector-page-tools-unpinned-container .mw-menu-inactive{ background-color:lightsteelblue; color:white; } #mw-panel .vector-menu-heading, #vector-main-menu-pinned-container .vector-menu-heading, #vector-main-menu-unpinned-container .vector-menu-heading, #vector-page-tools-pinned-container .vector-menu-heading, #vector-page-tools-unpinned-container .vector-menu-heading{ padding-left:5px !important; padding-right:5px !important; margin-left:0 !important; display:block; border-radius:5px; border:1px solid #c8ccd1; margin-top:3px; margin-bottom:0; } #mw-panel .vector-menu-content:not(.mw-items-inactive), #vector-main-menu-unpinned-container .vector-menu-content:not(.mw-items-inactive), #vector-page-tools-pinned-container .vector-menu-content:not(.mw-items-inactive), #vector-page-tools-unpinned-container .vector-menu-content:not(.mw-items-inactive){ display:block; border-radius:5px; border:1px solid #c8ccd1; padding: 5px; margin-top:2px; } #mw-panel .vector-menu-content:not(.mw-items-inactive) > ul, #vector-main-menu-unpinned-container .vector-menu-content:not(.mw-items-inactive) > ul, #vector-page-tools-pinned-container .vector-menu-content:not(.mw-items-inactive) > ul, #vector-page-tools-unpinned-container .vector-menu-content:not(.mw-items-inactive) > ul{ margin-top:0; } #mw-panel .mw-items-inactive, #vector-main-menu-unpinned-container .mw-items-inactive, #vector-page-tools-pinned-container .mw-items-inactive, #vector-page-tools-unpinned-container .mw-items-inactive{ display:none; } .vector-main-menu #p-navigation .vector-menu-heading{ display:block; } #mw-panel .vector-main-menu-action, #vector-main-menu-unpinned-container .vector-main-menu-action, #vector-page-tools-pinned-container .vector-main-menu-action, #vector-page-tools-unpinned-container .vector-main-menu-action{ display:none; } #mw-panel.hidden_sidebar_panel{ position:relative; z-index:1; } #mw-panel.hidden_sidebar_panel > #hideSidebar_close_lpanel{ position:absolute; right:0; } #mw-panel.hidden_sidebar_panel > #vector-main-menu-pinned-container{ display:none; } #mw-panel #vector-main-menu-pinned-container{ padding-left:0 !important; } #vector-main-menu-pinned-container .vector-main-menu{ margin-left:0 !important; margin-top:0 !important; } #mw-data-after-content .cdx-card{ margin:5px 0; border-radius:10px; } .vector-unpinned-container .vector-menu{ margin:0 5px; } #mw-content-text .mw-parser-output code{ position:relative; } .mw-parser-output pre{ margin-top:8px; margin-bottom:8px; background-color: #f8f9fa; color: #000; border: 1px solid #eaecf0; word-wrap:break-word; word-break:break-word; hyphens:auto; box-sizing:border-box; font-size:110%; } .client-js .vector-search-box-vue .cdx-search-input{ position:relative; } .client-js .vector-search-box-vue .vector-typeahead-search .cdx-text-input__input{ border-right-color:#a2a9b1 !important; } .client-js .vector-search-box-vue .vector-typeahead-search .cdx-search-input__end-button{ position:absolute; right:0; } html.client-js .vector-search-box-vue .vector-typeahead-search--active .cdx-search-input__end-button, html.client-js .vector-search-box-vue .vector-typeahead-search:hover .cdx-search-input__end-button{ position:relative; } .mw-content-container #content{ border-radius:10px; border:1px solid #c8ccd1; padding:10px; padding-top:8px; } body:not(.action-view):not(.ns-special) .vector-body-before-content{ float:right; } body.ns-special .vector-body-before-content .mw-indicators{ margin-top:6px; float:right; padding-top:0; } body:not(.ns-special) .vector-body-before-content .mw-indicators{ margin-top:2px; float:right; padding-top:0; margin-bottom:0.2px; } .vector-body-before-content > .mw-indicators img, .mw-body-header .mw-indicators img{ max-height:1.7em; } body:not(.page-Wikibooks_Strona_główna).action-view:not(.ns-special) .vector-body-before-content::after{ content:''; display:block; clear:both; order:2; } body.action-view #bodyContent div#siteSub{ display:block !important; } body.action-view:not(.ns-special) .vector-body-before-content #siteSub{ display:block; float:left; order:1; margin-top:5px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; font-size:0.8125rem; line-height:1.4em; padding-bottom:1px; } body.action-view:not(.ns-special) .vector-body-before-content{ white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } body.action-view:not(.ns-special) .vector-body-before-content .mw-indicators{ order:3; white-space:nowrap; } body.action-view:not(.ns-special) .vector-body-before-content{ border-bottom:1px solid #c8ccd1; padding-bottom:3px; display:flex; flex-direction:row; justify-content:space-between; align-items: flex-end; } #mw-content-text{ margin-top:10px; } .catlinks{ margin-top:7px !important; } .mw-category-generated > :first-child > h2:first-child{ margin-top:14px; } body.ns-14 .mw-category-generated > p:only-child{ border:1px solid #c8ccd1; padding:5px; margin-top:5px; margin-bottom:5px; } body.ns-14 .mw-parser-output.blank{ margin-top:-3px; } body.ns-14 .mw-parser-output.blank ~ .printfooter{ margin-top:3px; } #content::after{ content:''; clear:both; display:block; } #bodyContent{ margin-bottom:0; box-sizing: border-box; } body.action-edit #bodyContent #editform{ margin-top:5px; } body{ font-family: Arial, Helvetica, "Free Helvetian", FreeSans, sans-serif; font-stretch:normal; font-variant:normal; font-style:normal; font-weight:normal; font-size-adjust:none; letter-spacing:normal; word-spacing:normal; text-align:left; word-wrap:break-word; hyphens:auto; } body.action-history #mw-content-text > *:first-child{ margin-top:8px; } .mw-parser-output hr{ font-size:1.2em; } #mw-content-text, #mw-content-text .mw-message-box-warning, #mw-content-text .mw-parser-output{ font-size: calc(0.875rem * 0.89944); line-height: 1.4em; } .mw-ui-icon{ font-size:1rem; } body{ font-size:1rem; line-height:1.4em; } /**/ body.action-view #mw-content-text .mw-parser-output:first-child:not(.blank)::before, body.action-view #mw-content-text .mw-parser-output.first-child:not(.blank)::before{ content:''; clear:both; display:block; } body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view #mw-content-text .mw-parser-output:first-child:not(.blank)::before, body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view #mw-content-text .mw-parser-output.first-child:not(.blank)::before{ margin-bottom:8px; } body.page-Wikibooks_Strona_główna:not(.ns-special).action-view #mw-content-text .mw-parser-output:first-child:not(.blank)::before, body.page-Wikibooks_Strona_główna:not(.ns-special).action-view #mw-content-text .mw-parser-output.first-child:not(.blank)::before{ margin-bottom:0; } body.action-view:not(.ns-14) #mw-content-text .mw-parser-output:last-child:not(.blank)::after, body.action-view:not(.ns-14) #mw-content-text .mw-parser-output.last-child:not(.blank)::after{ content:''; clear:both; display:block; } body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view:not(.ns-14) #mw-content-text .mw-parser-output:last-child:not(.blank)::after, body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view:not(.ns-14) #mw-content-text .mw-parser-output.last-child:not(.blank)::after{ margin-top:3px; } body.page-Wikibooks_Strona_główna.action-view #mw-content-text .mw-parser-output:last-child:not(.blank)::after, body.page-Wikibooks_Strona_główna.action-view #mw-content-text .mw-parser-output.last-child:not(.blank)::after{ margin-top:0; } body.ns-special.action-view #mw-content-text .mw-parser-output:first-child:not(.blank)::before, body.ns-special.action-view #mw-content-text .mw-parser-output.first-child:not(.blank)::before{ margin-bottom:0; } body.ns-special.action-view #mw-content-text .mw-parser-output:last-child:not(.blank)::after, body.ns-special.action-view #mw-content-text .mw-parser-output.last-child:not(.blank)::after{ margin-top:0; } /**/ body.action-view #mw-content-text .mw-parser-output:first-child:not(.is-only-whitespace)::before, body.action-view #mw-content-text .mw-parser-output.first-child:not(.is-only-whitespace)::before{ content:''; clear:both; display:block; } body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view #mw-content-text .mw-parser-output:first-child:not(.is-only-whitespace)::before, body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view #mw-content-text .mw-parser-output.first-child:not(.is-only-whitespace)::before{ margin-bottom:8px; } body.page-Wikibooks_Strona_główna:not(.ns-special).action-view #mw-content-text .mw-parser-output:first-child:not(.is-only-whitespace)::before, body.page-Wikibooks_Strona_główna:not(.ns-special).action-view #mw-content-text .mw-parser-output.first-child:not(.is-only-whitespace)::before{ margin-bottom:0; } body.action-view:not(.ns-14) #mw-content-text .mw-parser-output:last-child:not(.is-only-whitespace)::after, body.action-view:not(.ns-14) #mw-content-text .mw-parser-output.last-child:not(.is-only-whitespace)::after{ content:''; clear:both; display:block; } body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view:not(.ns-14) #mw-content-text .mw-parser-output:last-child:not(.is-only-whitespace)::after, body:not(.ns-special):not(.page-Wikibooks_Strona_główna).action-view:not(.ns-14) #mw-content-text .mw-parser-output.last-child:not(.is-only-whitespace)::after{ margin-top:3px; } body.page-Wikibooks_Strona_główna.action-view #mw-content-text .mw-parser-output:last-child:not(.is-only-whitespace)::after, body.page-Wikibooks_Strona_główna.action-view #mw-content-text .mw-parser-output.last-child:not(.is-only-whitespace)::after{ margin-top:0; } body.ns-special.action-view #mw-content-text .mw-parser-output:first-child:not(.is-only-whitespace)::before, body.ns-special.action-view #mw-content-text .mw-parser-output.first-child:not(.is-only-whitespace)::before{ margin-bottom:0; } body.ns-special.action-view #mw-content-text .mw-parser-output:last-child:not(.is-only-whitespace)::after, body.ns-special.action-view #mw-content-text .mw-parser-output.last-child:not(.is-only-whitespace)::after{ margin-top:0; } /**/ body:not(.page-Wikibooks_Strona_główna) .printfooter{ display:block; padding:5px; border:1px solid #c8ccd1; margin-top:6px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; clear:both; } .noarticletext{ margin-top:0; margin-bottom:7px; } body.action-view #bodyContent #contentSub{ display:block !important; } #contentSub{ margin-top:5px !important; } #contentSub > #pwContent > #pwPathway, #contentSub > #pwContent > #pwPathway + #pwNav, #contentSub > #mw-content-subtitle, #contentSub > #mw-content-subtitle > .subpages, #contentSub2 > .subpages > .mw-undelete-subtitle{ font-size:0.75rem; line-height:1.2em; } #contentSub2{ margin-top:4px !important; } #contentSub2 > .subpages{ border-bottom:1px solid #c8ccd1; padding-bottom:5px; padding-top:2px; } #pwContent:not(:empty){ border-bottom:1px solid #c8ccd1; padding-bottom:3px; font-size:100%; } html:not(.client-nojs) body:not(.mw-special-Watchlist) #mw-content-subtitle:not(:empty), html.client-nojs #mw-content-subtitle:not(:empty){ border-bottom:1px solid #c8ccd1; padding-bottom:3px; } #mw-content-subtitle > .subpages:not(:last-child){ border-bottom:1px solid #c8ccd1; padding-bottom:3px; } #mw-content-subtitle .mw-message-box-warning:not(:last-child){ margin:10px 0; } #mw-content-subtitle .mw-message-box-warning:last-child{ margin:10px 0 8px 0; } body.action-edit #mw-content-text > :not(.mw-editnotice):not(.mw-parser-output):not(.mw-message-box-warning):first-child{ margin-top:10px !important; margin-bottom:10px !important; } #mw-content-subtitle #redirectsub, #mw-content-subtitle .mw-redirectedfrom{ display:block; margin: 5px 0 2px 0; } #mw-content-subtitle .mw-redirectedfrom:not(:last-child){ border-bottom: 1px solid #c8ccd1; } #mw-content-text > .mw-message-box-warning:first-child{ margin:10px 0; } #mw-content-text > .mw-message-box-warning{ margin:5px 0 10px 0; } body.action-edit #mw-content-text > .mw-editnotice:first-child{ margin-top:12px; } body.action-edit #mw-content-text > :not(.mw-editnotice):not(.mw-parser-output):not(.mw-message-box-warning):first-child{ margin-top:-3px; } body.action-view.ns-special #mw-content-text > :not(div):not(p):first-child{ margin-top:18px; } body:not(.action-view) #mw-content-text > p:first-child{ margin-top:3px; } #contentsub::after{ content:''; display:block; } .previewnote, #wikiPreview.ontop{ margin-bottom:10px; max-width:unset; } body.action-submit #mw-content-text > #wikiPreview > .previewnote > #mw-previewheader{ margin-top:0.8em; margin-bottom:0.4em; } div.thumb.tright:first-child, div.thumb.tleft:first-child{ margin-top:0; } #mw-content-text .mw-parser-output > p:first-child{ margin-top:0; } #mw-content-text .mw-parser-output > p:not(.br-clear-both):last-child{ margin-bottom:0; } #mw-content-text .mw-parser-output > :not(p).floatleft:first-child + p, #mw-content-text .mw-parser-output > :not(p).floatright:first-child + p, #mw-content-text .mw-parser-output > :not(p).tleft:first-child + p, #mw-content-text .mw-parser-output > :not(p).tright:first-child + p{ margin-top:0; } #mw-content-text .mw-parser-output .template-documentation:first-of-type{ margin-top:0; box-sizing:border-box; } #mw-content-text .mw-parser-output > :not(style):not(link) ~ .template-documentation{ margin-top:10px !important; box-sizing:border-box !important; } #mw-content-text .mw-parser-output #documentation-meta-data:not(:last-child){ margin-top:3px !important; margin-bottom:3px !important; } #mw-content-text .mw-parser-output #documentation-meta-data:last-child{ margin-top:3px !important; margin-bottom:0 !important; } body.ns-14 .mw-category-generated > * > .mw-content-ltr > .mw-category > .mw-category-group > h3.only-whitespace.is-only-whitespace::before{ display:block; content:'(pusta)'; float:left; } .vector-body{ font-size: calc(1rem * 0.875); line-height: 1.5em; } @media all and (min-width:999px){ html.vector-feature-page-tools-pinned-enabled #bodyContent.vector-body, html.vector-feature-appearance-pinned-clientpref-1 #bodyContent.vector-body{ border-right: 1px solid #c8ccd1; border-bottom:1px solid #c8ccd1; padding-right:0.625rem; padding-bottom:0.625rem; } } .vector-toc .vector-toc-list-item a{ font-size:0.8125rem; line-height:1.4em; } .wb-langlinks-link > a::before{ margin-left:-8px; } /**/ .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:hover, .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:active:hover, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:hover, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:active:hover, .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:active:hover, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:active:hover{ display:block; outline:1px solid #eaecf0; border-radius:10px; box-sizing:border-box; width:100%; } .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:hover, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:hover{ background-color:blue !important; } .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:active:hover, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:active:hover, .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:active:hover, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:active:hover{ background-color:green !important; } .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:hover, .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:hover, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:hover{ color:white !important; } .vector-pinned-container .vector-toc ul.vector-toc-contents li > a, .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a, .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a, .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a{ display:block; width:100%; text-decoration:none; font-size: 0.8125rem; line-height:1.4em; box-sizing:border-box; padding:0 5px !important; } .vector-feature-toc-pinned-clientpref-1.vector-toc-available #vector-toc-pinned-container{ margin-top:0; } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available .vector-main-menu-container{ margin-bottom:5px; } .vector-column-start .vector-main-menu-container, html.vector-feature-toc-pinned-clientpref-1.vector-toc-available .vector-column-start .vector-sticky-pinned-container{ margin-left:12px; } @media (min-width: 999px){ html.vector-feature-toc-pinned-clientpref-1.vector-toc-available #vector-toc-pinned-container{ border-radius:10px; border:1px solid #c8ccd1; padding:8px; padding-left:6px; } } #mw-panel-toc-list{ margin-top:6px; } #vector-toc-pinned-container .vector-toc::after{ display:none; } .vector-toc .vector-toc-text{ padding: 3px 0 !important; } button.cdx-button{ z-index:1; } .vector-menu-tabs .mw-list-item.vector-tab-noicon > a, .vector-page-toolbar-container .vector-dropdown.vector-tab-noicon > a, .vector-menu-tabs .mw-list-item .vector-dropdown-label, .vector-page-toolbar-container .vector-dropdown .vector-dropdown-label{ padding-bottom:3px; margin-bottom:-1px; } .vector-menu-tabs .mw-list-item > a, .vector-page-toolbar-container .vector-dropdown > a, .vector-menu-tabs .mw-list-item .vector-dropdown-label, .vector-page-toolbar-container .vector-dropdown .vector-dropdown-label{ max-height:37px; line-height:1.4em; } .mw-diff-table-prefix{ max-width:calc( 100% - 2em ); } .vector-column-start{ border-top:0; margin-top:0; } html.vector-feature-page-tools-pinned-enabled .vector-column-end, html.vector-feature-appearance-pinned-clientpref-1 .vector-column-end{ margin-top:0; margin-left:-1px; border: 1px solid #c8ccd1; border-top:0; padding-top:2px; } .vector-column-start .vector-sticky-pinned-container{ margin-left:0; } .vector-header-container .mw-header{ max-width:none; min-width:auto; } .vector-header-container{ padding-left:0; padding-right:0; } .vector-header-container .mw-header{ padding-left:1.5rem; padding-right:1.5rem; } .client-js.vector-feature-toc-pinned-clientpref-0 body:not(.vector-sticky-header-visible) .vector-page-titlebar-toc{ margin-right:0; } html.vector-feature-toc-pinned-clientpref-1.vector-toc-available #vector-toc-pinned-container{ padding-left:15px; } .vector-pinned-container{ padding: 16px 8px; padding-top:5px; padding-bottom:0; } .vector-dropdown .vector-dropdown-content{ padding-right:4px; padding-bottom:0; /*width:800px;*/ } .vector-dropdown#vector-page-titlebar-toc .vector-dropdown-content{ padding-left:12px } .vector-dropdown#vector-page-tools-dropdown .vector-dropdown-content{ padding-left:4px; padding-bottom:8px; } .vector-dropdown#vector-main-menu-dropdown .vector-dropdown-content{ padding-left:4px; } .client-js.vector-feature-toc-pinned-clientpref-0 body:not(.vector-sticky-header-visible) .vector-page-titlebar-toc .vector-dropdown-content{ /*max-width:200px;*/ } .mw-header{ grid-template: auto / 15em minmax(0,1fr); grid-template-areas:'headerStart headerEnd'; } #p-navigation.mw-portlet-navigation{ margin-top:0px; } .vector-menu.mw-portlet:not(.mw-portlet-navigation){ margin-top:4px; } .vector-toc .vector-toc-list-item-active > .vector-toc-link .vector-toc-text, .vector-toc .vector-toc-level-1-active:not(.vector-toc-list-item-expanded) > .vector-toc-link .vector-toc-text, .vector-toc .vector-toc-list-item-active.vector-toc-level-1-active > .vector-toc-link .vector-toc-text{ width:unset !important; } html.skin-theme-clientpref-night > body .vector-page-toolbar-container .vector-dropdown{ border-bottom:1px solid black; } html.skin-theme-clientpref-night > body ul.redirectText > li{ background-color:white !important; } html.skin-theme-clientpref-night > body ul.redirectText > li a{ background-color:black !important; color:white !important; } html.skin-theme-clientpref-night > body .mw-revslider-revision{ background-color:white !important; z-index:2; } html.skin-theme-clientpref-night > body .mw-revslider-revision > .mw-revslider-revision-border-box{ background-color:transparent !important; } html.skin-theme-clientpref-night > body > .mw-revslider-revision-tooltip{ filter:grayscale(100%); } html.skin-theme-clientpref-night > body span.ext-discussiontools-init-replylink-buttons{ border-color:none; color:white; background-color:unset; border-color:unset; } html.skin-theme-clientpref-night > body > .mw-page-container, html.skin-theme-clientpref-night > body > .mw-page-container > .mw-page-container-inner{ filter:grayscale(100%); } html.skin-theme-clientpref-night > body.action-view td.diff-deletedline .diffchange, html.skin-theme-clientpref-night > body.action-submit td.diff-deletedline .diffchange{ background: var(--background-color-content-removed,#ffe49c); filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body.action-view td.diff-addedline .diffchange, html.skin-theme-clientpref-night > body.action-submit td.diff-addedline .diffchange{ background: var(--background-color-content-added,#a3d3ff); filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body .imeselector{ background: var(--background-color-content-added,#a3d3ff); filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body, html.skin-theme-clientpref-night > body > .mw-page-container, html.skin-theme-clientpref-night > body > .mw-page-container :not(.redirectText) > *:not(img):not(.vector-icon):not(hr):not(br):not(.mw-notification-area-overlay):not(.redirectText), html.skin-theme-clientpref-night > body > .mw-page-container > *:not(img):not(.vector-icon):not(hr):not(br):not(.mw-notification-area-overlay):not(.redirectText), html.skin-theme-clientpref-night > body > .vector-header-container, html.skin-theme-clientpref-night > body > .vector-header-container *:not(img):not(.vector-icon):not(hr):not(br):not(.mw-notification-area-overlay){ color:white; background-color:black; border-color:white; } html.skin-theme-clientpref-night > body > div.ui-dialog, html.skin-theme-clientpref-night > body > div.ui-dialog *{ background-color:black; color:white; border-color:white; } html.skin-theme-clientpref-night > body > div.ui-dialog > div.ui-dialog-titlebar{ background-image:unset !important; background-color:black !important; } html.skin-theme-clientpref-night > body > div.ui-dialog > div.ui-dialog-content > fieldset > div.wikieditor-toolbar-field-wrapper > input:focus{ filter:invert(100%) grayscale(100%); background-color:transparent !important; } html.skin-theme-clientpref-night > body > #mw-teleport-target{ filter:grayscale(100%); } html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output span[typeof="mw:File"], html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output span[typeof="mw:File"] *, html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output figure[typeof="mw:File"], html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output figure[typeof="mw:File"] *{ background-color:transparent !important; color:unset !important; background-color:unset !important; } html.skin-theme-clientpref-night > body > .mw-page-container .imeselector, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output img, html.skin-theme-clientpref-night > body > .mw-page-container .mw-footer-container img{ filter:invert(100%) grayscale(100%) !important; background-color:transparent !important; } html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output, html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output :not(.redirectText) > *:not(img):not(.redirectText), html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output > *:not(img):not(.redirectText){ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body .vector-pinned-container .vector-toc ul.vector-toc-contents li a, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a, html.skin-theme-clientpref-night > body .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a{ z-index:0 !important; position:relative !important; } html.skin-theme-clientpref-night > body .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:hover, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:hover, html.skin-theme-clientpref-night > body .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:hover, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:hover{ background-color:black !important; color:white !important; border-color:white !important; z-index:1 !important; position:relative !important; } html.skin-theme-clientpref-night > body #mw-content-text > div.printfooter{ z-index:1; position:relative; } html.skin-theme-clientpref-night > body .mw-footer-container, html.skin-theme-clientpref-night > body .mw-footer-container *:not(img), html.skin-theme-clientpref-night > body form.mw-editform .editButtons, html.skin-theme-clientpref-night > body form.mw-editform .editButtons *, html.skin-theme-clientpref-night > body .vector-menu-heading, html.skin-theme-clientpref-night > body .vector-menu-heading *, html.skin-theme-clientpref-night > body > .mw-page-container div.group > div.tool > div.menu, html.skin-theme-clientpref-night > body > .mw-page-container div.group > div.tool > div.menu *{ color:white !important; background-color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body > div.uls-menu, html.skin-theme-clientpref-night > body > div.uls-menu *:not(.oo-ui-iconElement-icon), html.skin-theme-clientpref-night > body > .language-settings-dialog, html.skin-theme-clientpref-night > body > .language-settings-dialog *:not(.oo-ui-iconElement-icon){ color:white; background-color:black; border-color:white; filter:invert(0%); } html.skin-theme-clientpref-night > body > div.uls-menu .oo-ui-iconElement-icon{ background-color:transparent !important; filter:invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .row .uls-display-settings-tab-switcher, html.skin-theme-clientpref-night > body > .language-settings-dialog .uls-sub-panel{ background-color:transparent !important; border:0 !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .row .uls-display-settings-tab-switcher button, html.skin-theme-clientpref-night > body > .language-settings-dialog .uls-sub-panel button{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .settings-text:hover{ background-color:white!important; color:black !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .settings-text:not(:hover){ background-color:black!important; color:white !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog #languagesettings-settings-panel{ background-color:transparent !important; } html.skin-theme-clientpref-night > body > .vector-header-container #p-vector-user-menu-userpage a{ font-weight:bolder; } html.skin-theme-clientpref-night > body::selection, html.skin-theme-clientpref-night > body *::selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body::-moz-selection html.skin-theme-clientpref-night > body *::-moz-selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body div#mw-abusefilter-examine-editor div.ace_editor > div.ace_scroller > div.ace_content > div.ace_marker-layer > div.ace_selection, html.skin-theme-clientpref-night > body form#wpFilterForm div.ace_editor > div.ace_scroller > div.ace_content > div.ace_marker-layer > div.ace_selection, html.skin-theme-clientpref-night > body form#mw-abusefilter-editing-form div.ace_editor > div.ace_scroller > div.ace_content > div.ace_marker-layer > div.ace_selection, html.skin-theme-clientpref-night > body form.mw-editform div.ace_editor > div.ace_scroller > div.ace_content > div.ace_marker-layer > div.ace_selection{ background-color:dimgray !important; color:black !important; border-color:white !important; filter:grayscale(100%); } html.skin-theme-clientpref-night div.ui-resizable > div.ace_editor > div.ace_scroller > div.ace_search, html.skin-theme-clientpref-night div.ui-resizable > div.ace_editor > div.ace_scroller > div.ace_search *, html.skin-theme-clientpref-night div.ui-resizable > div.ace_editor > div.ace_scroller > div.ace_search input.ace_search_field{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body hr, html.skin-theme-clientpref-night > body > .mw-page-container .cdx-message__icon{ filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body span.ext-discussiontools-init-replylink-buttons, html.skin-theme-clientpref-night > body span.ext-discussiontools-init-replylink-buttons *{ color:white !important; background-color:black !important; border:0 !important; } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content *{ color:white; background-color:black; border-color:white; } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content .oo-ui-image-success{ background-color:unset; } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content a{ font-weight:bolder; } html.skin-theme-clientpref-night > body span.link > a, html.skin-theme-clientpref-night > body span.link > a:link, html.skin-theme-clientpref-night > body span.link > a:visited, html.skin-theme-clientpref-night > body span.link > a:hover, html.skin-theme-clientpref-night > body span.link > a:active{ color:white; background-color:black; border-color:none; font-weight:bold; } html.skin-theme-clientpref-night > body img.mw-logo-icon{ background-color:white; color:black; border-color:black; } html.skin-theme-clientpref-night > body .cdx-button:enabled.cdx-button--weight-quiet:hover{ background-color: gray; mix-blend-mode:unset; } html.skin-theme-clientpref-night > body .uls-language-actions-close, html.skin-theme-clientpref-night > body .uls-settings-block--with-add-languages, html.skin-theme-clientpref-night > body a.mw-logo img, html.skin-theme-clientpref-night > body span.vector-icon img{ filter:invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body a.mw-logo img.mw-logo-icon{ background-color:white; } html.skin-theme-clientpref-night > body a.mw-logo img.mw-logo-wordmark{ background-color:black; } html.skin-theme-clientpref-night > body a.mw-logo{ background-color:black; } html.skin-theme-clientpref-night > body span.vector-icon{ background-color:white; } @media screen { html.skin-theme-clientpref-night span.tab > a.skin-invert, html.skin-theme-clientpref-night a.skin-invert.label, html.skin-theme-clientpref-night div.tabs > span > a.skin-invert{ color-scheme:unset !important; filter:none !important; } } @media screen { html.skin-theme-clientpref-night .skin-invert-image img, html.skin-theme-clientpref-night .skin-invert.label::after, html.skin-theme-clientpref-night .skin-invert.current::before, html.skin-theme-clientpref-night .oo-ui-iconElement-icon, html.skin-theme-clientpref-night .oo-ui-indicatorElement-indicator, html.skin-theme-clientpref-night div.tabs > span > a.skin-invert::before, html.skin-theme-clientpref-night label.mw-enhancedchanges-arrow, html.skin-theme-clientpref-night input[type="checkbox"]{ color-scheme: light !important; filter: invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night input[type="radio"] + span.cdx-radio__icon, html.skin-theme-clientpref-night input[type="radio"]:hover + span.cdx-radio__icon{ filter:grayscale(100%) !important; } } html.skin-theme-clientpref-night > body div#mw-teleport-target > div.mw-rcfilters-ui-overlay > .oo-ui-widget, html.skin-theme-clientpref-night > body div#mw-teleport-target > div.mw-rcfilters-ui-overlay > .oo-ui-widget *{ filter:invert(0%) grayscale(100%); } div.vector-main-menu > div.mw-portlet > button.uls-settings-trigger, html.skin-theme-clientpref-night > body form.mw-editform:not(img):not(.vector-icon):not(hr):not(br):not(.mw-notification-area-overlay), html.skin-theme-clientpref-night > body form.mw-editform:not(img):not(.vector-icon):not(hr):not(br):not(.mw-notification-area-overlay) *, html.skin-theme-clientpref-night > body form#mw-abusefilter-editing-form, html.skin-theme-clientpref-night > body form#mw-abusefilter-editing-form *, html.skin-theme-clientpref-night > body form#wpFilterForm, html.skin-theme-clientpref-night > body form#wpFilterForm *, html.skin-theme-clientpref-night > body div#mw-abusefilter-examine-editor, html.skin-theme-clientpref-night > body div#mw-abusefilter-examine-editor *, html.skin-theme-clientpref-night > body div#vector-appearance-pinned-container, html.skin-theme-clientpref-night > body div#vector-appearance-pinned-container *, html.skin-theme-clientpref-night > body div#vector-appearance-unpinned-container, html.skin-theme-clientpref-night > body div#vector-appearance-unpinned-container *, html.skin-theme-clientpref-night > body div.mw-rcfilters-container, html.skin-theme-clientpref-night > body div.mw-rcfilters-container *, html.skin-theme-clientpref-night > body div.mw-rcfilters-ui-rcTopSectionWidget-topLinks-top, html.skin-theme-clientpref-night > body div.mw-rcfilters-ui-rcTopSectionWidget-topLinks-top *, html.skin-theme-clientpref-night > body > .mw-page-container span.oo-ui-iconElement-icon, html.skin-theme-clientpref-night > body > .mw-page-container span.oo-ui-iconElement-icon *, html.skin-theme-clientpref-night > body .oo-ui-indicatorElement-indicator, html.skin-theme-clientpref-night > body .oo-ui-buttonElement-framed.oo-ui-widget-enabled.oo-ui-flaggedElement-primary.oo-ui-flaggedElement-destructive > .oo-ui-buttonElement-button, html.skin-theme-clientpref-night > body .oo-ui-labelElement-label{ background-color:unset !important; } html.skin-theme-clientpref-night > body .oo-ui-buttonElement-framed.oo-ui-widget-enabled.oo-ui-flaggedElement-primary.oo-ui-flaggedElement-progressive > .oo-ui-buttonElement-button{ background-color:black; } html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight > pre{ position:relative; box-shadow:none; } html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight > pre, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight > pre *, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner :not(.mw-highlight) > pre, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner :not(.mw-highlight) > pre *{ background-color:black; color:white; border-color:white; } html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight pre > span.hll, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight pre > span.hll *, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight pre > span.hll a linenos, html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight pre > span a:hover .linenos{ background-color: white; color: black; border-color:white; } html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight pre > span a:not(:hover) .linenos{ color:white; background-color:black; border-color:white; } @media not screen{ } html.vector-feature-custom-font-size-clientpref-0{ font-size:14px; } html.vector-feature-custom-font-size-clientpref-1{ font-size:16px; } html.vector-feature-custom-font-size-clientpref-2{ font-size:18px; } fsxr6yrwxf9q1mmpwoek0gmxn7qef5y 0 60076 539829 529016 2026-04-14T16:34:42Z Persino 2851 539829 wikitext text/x-wiki {{Podrozdział|Wstęp}} Poradnik szeroko obejmujący zagadnienia codziennej egzystencji bardzo oczywiste, ale też takie co uchodzą za mniej domyślne. == Co znajdziesz w tym poradniku? == W niniejszym poradniku możesz znaleźć, ale też opisać (jeśli nie zostało to zrobione dotychczas) opisy i instrukcje czynności z pozoru błahych, ale ważnych w życiu codziennym. Z pewnością kiedyś to, co robimy tak a nie inaczej, będzie wykonywane w zupełnie inny sposób. Ku pamięci potomnych, ale też na użytek osób uczących się dopiero życia w naszym społeczeństwie (na przykład cudzoziemców) te wskazówki mogą okazać się bardzo ważne. Nie zawsze znajdziesz tu gotową odpowiedź. Czasem będą to jedynie pytania które, mamy nadzieję, pomogą znaleźć najlepsze dla siebie rozwiązanie. == Autorzy == * [[Wikipedysta:Superjurek|Jerzy Kamiński]] * [[Wikipedysta:Marek Mazurkiewicz|Marek Mazurkiewicz]] doe4ug08dfsw8uciae1tz020e7coi2t 0 60077 539832 478569 2026-04-14T16:36:59Z Persino 2851 539832 wikitext text/x-wiki {{Podrozdział|styl=display:table !important;|Rachunki}} W codziennym życiu wiele inicjatyw wymaga nakładów finansowych. Istotne jest, by osoba dorosła (a więc taka, która jest zdolna do podmiotowego i autonomicznego funkcjonowania) miała stałe źródło pieniędzy koniecznych do rutynowych wydatków, takich jak: * zakupy dóbr i usług pierwszej potrzeby (woda, jedzenie, środki higieny osobistej, leki, hospitalizacja, zabiegi stomatologiczne) * zakupy dóbr i usług luksusowych (używki, zabawki, książki, filmy, muzyka, opieka zdrowotna) * opłaty za inwestycje w rozwój (studia, kursy, terapie, rehabilitacje), * podatki, * czynsz. == Rozliczenia gotówkowe == Gotówka jako fizyczny nośnik waluty jest podstawowym środkiem płatniczym w prawie wszystkich krajach (niektóre aktualnie odchodzą od wykorzystania gotówki na rzecz form bezgotówkowych). {{Definicja|styl=display:table !important;| '''gotówka''' – fizyczna forma pieniądza, w postaci monet oraz banknotów '''nominał''' – fizyczny element gotówki, o określonej i stałej wartości, stanowiący niepodzielną całość, przekazywany kontrahentowi w celu rozliczenia finansowego '''należność''' – kwota, jaką jesteśmy winni kontrahentowi '''nadpłata''' – kwota przekazywana kontrahentowi, które jest wyższa od należności, ale możliwa do zapłacenia przez nas nominałami, którymi dysponujemy '''reszta''' – kwota dopełniająca należość do nadpłaty, oddawana nam przez kontrahenta }} === Rozmienianie pieniędzy === Najczęstszym problemem w trakcie zakupów płaconych gotówkowo jest szybkie i jednocześnie bezbłędne wydanie '''reszty''' – w przypadku, gdy płacimy za zakupy poprzez '''nadpłatę'''. Nadpłata polega na tym, że wręczamy kasjerowy kwotę większą niż jesteśmy winni, po czym kasjer zobowiązany jest wręczyć nam "resztę" czyli takie nonimały, które w sumie mają dopełnić należność za zakupy do kwoty, którą klient wręczył kasjerowi. Pamiętać należy, że kasjer zgodnie z regułami współżycia społecznego powinien (choć prawnie nie jest do tego zobowiązany) wydać resztę, jeśli dysponuje odpowiednimi ku temu nominałami. Jeśli kasjer nie dysponuje odpowiednimi nominałami może poprosić klienta o taką kwotę, która umożliwi rozmienienie, problem wówczas zaczyna leżeć po stronie klienta (oczekuje się, aby klient w miarę możliwości dysponował gotówką jak najdokładniej odpowiadającą należności). {{uwaga|styl=display:table !important;|W Polsce sprzedawca nie ma obowiązku posiadać reszty na wydanie. To kupujący jest zobowiązany zapłacić odpowiednią kwotę.}} Stałe zapewnienie odpowiednich nominałów w tym układzie może być uciążliwe nie tylko dla kasjera (który co chwilę mierzy się z konieczością sprawiedliwego wydania reszty kolejnym klientom). Może to być również problem dla nas samych: gdy chcemy rozliczyć się z kilkoma osobami na raz i każdemu chcemy wydać dokładną, należną mu kwotę, mając jednak ograniczoną ilość poszczególnych nominałów. W takich sytuacji należy wydawać możliwie "najgrubszymi" nominałami, aby nie utracić zdolności do wydania precyzyjnej reszty w relacji z następnymi kontrahentami. {{uwaga|styl=display:table !important;|Koniecznie miej w domu przynajmniej niewielki zapas gotówki w postaci wszystkich dostępnych nominałów. Warto by nominały były posortowane i przechowywane w oddzielnych przegródkach (tacka na bilon, sakiewki lub pudełeczka).}} Jeśli masz problem z prawidłowym rozmienianiem nominałów, możesz skorzystać z następującego kalkulatora gotówkowego. {{dopracować|Tu będzie inputbox wykonujący skrypt z Modułu LUA [[Moduł:Rozmieniarka]]}} Niniejszy kalkulator możesz też wykorzystać we własnym oprogramowaniu, kod źródłowy jest następujący: <syntaxhighlight lang=lua line> function calculateNominals(amount) local nominals = {500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01} local result = {} for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal) if count > 0 then table.insert(result, {nominal = nominal, count = count}) amount = amount - (nominal * count) end end return result end -- Przykładowe użycie: local amount = 123.45 local result = calculateNominals(amount) print("Kwota:", amount) print("Nominały:") for _, entry in ipairs(result) do print(entry.nominal, "x", entry.count) end </syntaxhighlight> Możesz też skorzystać z kalkulatora o bardziej zaanwansowanej budowie. W poniższym kalkulatorze możesz wpisać iloma sztukami danego nominału dysponujesz (co jest istotne jeśli któregoś nominału Ci brakuje, wówczas kalkulator zaproponuje w miejsce brakującego nominału odpowiednio więcej sztuk drobniejszych nominałów). {{dopracować|Tu będzie inputbox wykonujący skrypt z Modułu LUA [[Moduł:Rozmieniarka]] w wersji uwzględniającej ograniczoną ilość konkretnych nominałów}} Kod źródłowy kalkulatora o rozszerzonej funkcjonalności jest następujący: <syntaxhighlight lang=lua line> function calculateNominals(amount, limits) local nominals = {500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01} local result = {} for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal) if limits[nominal] ~= nil then count = math.min(count, limits[nominal]) end if count > 0 then table.insert(result, {nominal = nominal, count = count}) amount = amount - (nominal * count) end end return result end -- Przykładowe użycie: local amount = 123.45 local limits = { [10] = 2, -- limit dla nominału 10 [0.2] = 5, -- limit dla nominału 0.2 } local result = calculateNominals(amount, limits) print("Kwota:", amount) print("Nominały:") for _, entry in ipairs(result) do print(entry.nominal, "x", entry.count) end </syntaxhighlight> == Rozliczenia bezgotówkowe == Wszelkie formy rozliczeń finansowych, które opierają się na wymianie monet lub banknotów nazywamy bezgotówkowymi. Formy takie z reguły wymagają wykorzystania urządzeń elektronicznych, odnotowujących przeprowadzoną transakcję w systemie bankowości internetowej. Do przeprowadzenia rozliczenia bezgotówkowego konieczne jest posiadanie konta bankowego (są drobne wyjątki, na przykład dyspozycja przelewu na konto docelowe, którą czynimy bezpośrednio w oddziale banku jednocześnie przekazując ekspedientowi równowartość tej kwoty w gotówce + ewentualna prowizja). ciqn716pn6y69yun26noi0no4eldcdb 828 60080 539835 478565 2026-04-14T17:14:55Z Persino 2851 539835 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; function p.calculateNominals(frame) local TempFunc=function(i) return frame.args[i] and tonumber(mw.text.trim(frame.args[i])) or 0; end; local amount = TempFunc(1); local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local limits = {}; for i=1,#nominals,1 do limits[nominals[i]]=TempFunc(i+1);end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 6w596dlxj9bnc71ldtpdhu15t1pix73 539836 539835 2026-04-14T17:20:44Z Persino 2851 539836 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i) local _i=PobierzParametryRamki(i); return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local limits = {}; for i=1,#nominals,1 do limits[nominals[i]]=TempFunc(i+1);end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; ess33061eu41h1w502ybfknw4j1zbiz 539838 539836 2026-04-14T17:40:51Z Persino 2851 539838 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value]; end; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i) local _i=PobierzParametryRamki(i); return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do limits[nominals[i]]=TempFunc(i+1);end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; jijbvkewo3sm55gq6i0haw3e561j996 539839 539838 2026-04-14T17:46:56Z Persino 2851 539839 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value]; end; tab_nominals[1]=amount; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i) local _i=PobierzParametryRamki(i); return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do limits[nominals[i]]=TempFunc(i+1);end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 5qmrrjj7cukg20ajgpiytr5x3s2z0xa 539842 539839 2026-04-14T17:52:08Z Persino 2851 539842 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value]; end; tab_nominals[1]=amount; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i,nominal) local _i=PobierzParametryRamki(i) or PobierzParametryRamki(tostring(nominal).."zł"); return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; jka5qia0dlqkcw23xe2c4izw5id48wc 539843 539842 2026-04-14T17:55:03Z Persino 2851 539843 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value]; end; tab_nominals[1]=amount; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametryRamki(i) or PobierzParametryRamki("kwota"); else _i=PobierzParametryRamki(i) or PobierzParametryRamki(tostring(nominal).."zł"); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 7znoiev8zpc6gsgkvt26q0sqhkrcuhx 539850 539843 2026-04-14T18:14:03Z Persino 2851 539850 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"]; end; tab_nominals[1]=amount; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametryRamki(i) or PobierzParametryRamki("kwota"); else _i=PobierzParametryRamki(i) or PobierzParametryRamki(tostring(nominal).."zł"); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 0w9g6zetdavtfuqkckknxwdjorklcp1 539851 539850 2026-04-14T18:16:13Z Persino 2851 539851 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"]; end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametryRamki(i) or PobierzParametryRamki("kwota"); else _i=PobierzParametryRamki(i) or PobierzParametryRamki(tostring(nominal).."zł"); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 41bd02plkfrolijx3htf8p2jcggokbc 539856 539851 2026-04-14T18:35:54Z Persino 2851 539856 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametryRamki(i) or PobierzParametryRamki("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametryRamki(i) or PobierzParametryRamki(tostring(nominal).."zł") or (nominal_gr and PobierzParametryRamki(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; hbe1jak1i9u933e1ttvhnkw7p2lyv26 539861 539856 2026-04-14T18:42:20Z Persino 2851 539861 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; local nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(i) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#nominals,1 do local nominal=nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; q7e9x1rr2ldsuygdzeknug0a7y3inhm 539865 539861 2026-04-14T18:58:26Z Persino 2851 539865 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(p.nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(i) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; dlfwvzev0ebvnggxpq6p561w46gogyr 539866 539865 2026-04-14T18:59:14Z Persino 2851 539866 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(p.nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(i) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; c06ykt9g64ffwrayye7qmrbxnuxlqo0 539875 539866 2026-04-15T05:02:26Z Persino 2851 539875 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p = {}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(p.nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local TempFunc=function(i,nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(i) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; r283qz34m47bqet4jxjvwqhq5v6acmt 539876 539875 2026-04-15T05:10:12Z Persino 2851 539876 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(i) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; function p.createNominals(tab_ile_nominals,amount) local tab_nominals={}; for name,value in ipairs(p.nominals)do local nominal_gr=nil; if(value<1)then nominal_gr=value*100;end; tab_nominals[name+1]=tab_ile_nominals[value] or tab_ile_nominals[tostring(value).."zł"] or (nominal_gr and tab_ile_nominals[tostring(nominal_gr).."gr"] or nil); end; tab_nominals[1]=amount or tab_ile_nominals["kwota"]; return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,nominal); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; anp3x788glk54k2gtmsaihrrl032w0l 539877 539876 2026-04-15T05:28:22Z Persino 2851 539877 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,nominal,czy_nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local numer_lub_nominal=czy_nominal and p.nominals[i-1] or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,value,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,nominal,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 5ovbjxemn8k6sk6ia3bsleobssxsmrm 539878 539877 2026-04-15T05:39:15Z Persino 2851 539878 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,czy_nominal) local _i; if(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal=p.nominals[i-1]; local numer_lub_nominal=czy_nominal and nominal or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 28l43l33y83w3nhaoh0l6feih3vhoec 539879 539878 2026-04-15T05:44:57Z Persino 2851 539879 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,czy_nominal) local _i; if(i==-1)then local _i=PobierzParametr("wykaz"); return _i; elseif(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal=p.nominals[i-1]; local numer_lub_nominal=czy_nominal and nominal or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local czy_zwrocic_tablica=TempFunc(-1); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end if(czy_zwrocic_tablica)then return result;end; local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; cljit4rpbzpqvqx2v5w82xn2w45gusm 539880 539879 2026-04-15T05:47:39Z Persino 2851 539880 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,czy_nominal) local _i; if(i==-1)then local _i=PobierzParametr("wykaz"); return _i; elseif(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal=p.nominals[i-1]; local numer_lub_nominal=czy_nominal and nominal or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local czy_zwrocic_tablica=TempFunc(-1); local parametry_modul=require("Module:Parametry"); czy_zwrocic_tablica=parametry_modul.CzyTak(czy_zwrocic_tablica); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end if(czy_zwrocic_tablica)then return result;end; local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; nu26jkecmw0usxb2zd9o6wy4fatqp19 539881 539880 2026-04-15T06:05:35Z Persino 2851 539881 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01,}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,czy_nominal) local _i; if(i==-1)then local _i=PobierzParametr("wykaz"); return _i; elseif(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal=p.nominals[i-1]; local numer_lub_nominal=czy_nominal and nominal or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local czy_zwrocic_tablica=TempFunc(-1); local parametry_modul=require("Module:Parametry"); czy_zwrocic_tablica=parametry_modul.CzyTak(czy_zwrocic_tablica); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count}); amount = amount - (nominal * count); end end if(czy_zwrocic_tablica)then return result;end; local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; f12yh08wawb6j21m6mzoy5uvlg2q6n3 539892 539881 2026-04-15T07:58:08Z Persino 2851 539892 Scribunto text/plain -- Funkcja 'calculateNominals' służy do jednoznacznego ustalania takiej konfiguracji nominałów, aby były one jak najgrubsze (tym samym wydajemy kwotę możliwie najmniejszą ilością monet i/lub banknotów). local p={}; p.nominals={500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01,}; local TempFuncFrame=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); return function(i,czy_nominal) local _i; if(i==-1)then local _i=PobierzParametr("wykaz"); return _i; elseif(i==1)then _i=PobierzParametr(i) or PobierzParametr("kwota"); else local nominal=p.nominals[i-1]; local numer_lub_nominal=czy_nominal and nominal or i; local nominal_gr=nil; if(nominal<1)then nominal_gr=nominal*100;end; _i=PobierzParametr(numer_lub_nominal) or PobierzParametr(tostring(nominal).."zł") or (nominal_gr and PobierzParametr(tostring(nominal_gr).."gr") or nil); end; return _i and tonumber(mw.text.trim(_i)) or 0; end; end; function p.createNominals(tab_ile_nominals,amount) local TempFunc=TempFuncFrame(tab_ile_nominals); local tab_nominals={}; for name,value in ipairs(p.nominals)do local numer=name+1; tab_nominals[numer]=TempFunc(numer,true); end; tab_nominals[1]=amount or TempFunc(1); return tab_nominals; end; function p.HowMuchMoneyNominals(tab_nominals,ktory) return p.nominals[ktory],tab_nominals[ktory+1]; end; function p.calculateNominals(frame) local TempFunc=TempFuncFrame(frame); local czy_zwrocic_tablica=TempFunc(-1); local parametry_modul=require("Module:Parametry"); czy_zwrocic_tablica=parametry_modul.CzyTak(czy_zwrocic_tablica); local amount = TempFunc(1); local limits = {}; for i=1,#(p.nominals),1 do local nominal=p.nominals[i]; limits[nominal]=TempFunc(i+1,false); end; local result = {}; for _, nominal in ipairs(p.nominals) do local count = math.floor(amount / nominal); if limits[nominal] ~= nil and type(limits[nominal]) == 'number' then count = math.min(count, limits[nominal]); end if count > 0 then table.insert(result, {nominal = nominal, count = count,}); amount = amount - (nominal * count); end end if(czy_zwrocic_tablica)then return result;end; local str="Kwota: "..amount..", "; str=str.."Nominały: "; local str2=nil; for _, entry in ipairs(result) do str2=(str2 and (str2..", ") or "")..entry.nominal.." x "..entry.count; end; return str..(str2 or "brak").."."; end; return p; 1w916zszhl3q53ytwtyfh1grz9h99wz 828 60081 539837 478566 2026-04-14T17:32:53Z Persino 2851 /* Przykład */ 539837 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|1=123.45|6=2<!-- nominał 10-->|11=0.2<!--nominał 0.2-->}} </syntaxhighlight> Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 6 -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 11 -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1]=123.45, [6]=2--[[ nominał 10]], [11]=0.2--[[nominał 0.2]], }; mw.log(wynik); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> elp96lcpx5lzjdsxy61axn5yenwkf5a 539840 539837 2026-04-14T17:47:44Z Persino 2851 /* Przykład */ 539840 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|1=123.45|6=2<!-- nominał 10-->|11=0.2<!--nominał 0.2-->}} </syntaxhighlight> Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 0.2 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> awokwduxkao4xceji10nj4myw60tpn0 539841 539840 2026-04-14T17:48:38Z Persino 2851 /* Przykład */ 539841 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|1=123.45|7=2<!-- nominał 10-->|12=0.2<!--nominał 0.2-->}} </syntaxhighlight> Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 0.2 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> cnw7t1x3zbq6tp7yrzllzgxkk7zjfeb 539844 539841 2026-04-14T17:58:55Z Persino 2851 /* Przykład */ 539844 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest nominał dla danego numerka, który symbolizuje nominał: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 5 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> juq3rwdo84n9gb25eiq1ehtlvt3o8kf 539845 539844 2026-04-14T18:01:16Z Persino 2851 /* Przykład */ 539845 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest nominał dla danego numerka, który symbolizuje nominał: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Parametry|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 5 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }l local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> fka5gx9le1kzt6rb6476vlv6hbsez5n 539846 539845 2026-04-14T18:04:58Z Persino 2851 /* Przykład */ 539846 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest nominał dla danego numerka, który symbolizuje nominał: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 5 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }l local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> tnu3falt6d6l9ydt1vkauol0vksflrl 539847 539846 2026-04-14T18:06:18Z Persino 2851 /* Przykład */ 539847 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 5 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(limits,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }l local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> pb0c9yflpf3uponodgmq6l3zkjpmifo 539848 539847 2026-04-14T18:08:46Z Persino 2851 /* Przykład */ 539848 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- [[ nominał 10]]; [12] = 5 -- [[nominał 0.2]]; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 1lmm23skim9n3vlqiom7m9ltjm31b8y 539849 539848 2026-04-14T18:11:24Z Persino 2851 /* Przykład */ 539849 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10; [12] = 5 -- nominał 0.2; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> njk5in2bg7evqc4b5ti3nhzfwgk8thg 539852 539849 2026-04-14T18:18:36Z Persino 2851 /* Przykład */ 539852 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10 -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10; [12] = 5 -- nominał 0.2; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10 -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10 -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2 -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> o544mxf6u0m2dat1rsjx9tc25wyhsur 539853 539852 2026-04-14T18:26:29Z Persino 2851 /* Przykład */ 539853 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 8tryah5z9kcdgzic1cwtzk69ez6hevi 539854 539853 2026-04-14T18:27:19Z Persino 2851 /* Przykład */ 539854 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=0.2}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> jwzy63ndhfx9b60hgll7nsjan4m5wka 539855 539854 2026-04-14T18:29:17Z Persino 2851 /* Przykład */ 539855 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> mrhva9of6k5jcqwikyw2a24hi29830j 539857 539855 2026-04-14T18:37:04Z Persino 2851 /* Przykład */ 539857 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> knidi1byl7t6t2e4rsi8h2lqqud81ds 539862 539857 2026-04-14T18:43:32Z Persino 2851 /* Przykład */ 539862 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 6vz7hpv5wt2nw75is8rb5yqsmrvng5w 539864 539862 2026-04-14T18:52:26Z Persino 2851 /* Przykład */ 539864 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub bezposrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> qr8qnp86as7rmvf0ogt28f89jg9v59h 539869 539864 2026-04-14T19:16:56Z Persino 2851 /* Przykład */ 539869 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2 -- nominał 10zł; [12] = 5 -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> albo bezpośrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 6l3altyu7r6nwnnwy5miiq40b93ep15 539871 539869 2026-04-14T19:47:01Z Persino 2851 /* Przykład */ 539871 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2, -- nominał 10zł; [12] = 5, -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> albo bezpośrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 8uhk7w5t7nb8bidlirz8p3u0tydiyo9 539872 539871 2026-04-14T19:50:01Z Persino 2851 /* Przykład */ 539872 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == ,== Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2, -- nominał 10zł; [12] = 5, -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount, -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> albo bezpośrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount, -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> hujjwzq40fgofdr6elugr6xkn4zm35k 539873 539872 2026-04-14T19:50:15Z Persino 2851 /* Opis parametrów */ 539873 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2, -- nominał 10zł; [12] = 5, -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount, -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> albo bezpośrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount, -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 36mmmjhisxmkr2asn9xo6nr0uxoh7rl 539874 539873 2026-04-14T19:51:57Z Persino 2851 539874 wikitext text/x-wiki <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{#invoke:Rozmieniarka|calculateNominals|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} Przykładowe użycie w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); -- local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 -- local limits = { -- [10] = 2, -- limit dla nominału 10zł -- Parametr 7; -- [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; -- }; local wynik=rozmieniarka_modul.calculateNominals{ [1] = 123.45, -- kwota; [7] = 2, -- nominał 10zł; [12] = 5, -- nominał 0.2zł; }; </syntaxhighlight> lub inny przykład inaczej licząca liczbę nominałów: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { [10] = 2, -- limit dla nominału 10zł -- Parametr 7; [0.2] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals,amount); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local nominals = { ["kwota"] = amount, -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local frame=rozmieniarka_modul.createNominals(nominals); local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> albo bezpośrednio: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount, -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["0.2zł"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> lub inaczej: <syntaxhighlight lang="lua"> local rozmieniarka_modul=require("Module:Rozmieniarka"); local amount = 123.45; -- kwota: 123.45zł -- Parametr 1 local frame = { ["kwota"] = amount, -- kwota -- Parametr 1; ["10zł"] = 2, -- limit dla nominału 10zł -- Parametr 7; ["20gr"] = 5, -- limit dla nominału 0.2zł -- Parametr 12; }; local wynik=rozmieniarka_modul.calculateNominals(frame); </syntaxhighlight> == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> te3ehdcxblbpfciryw53xt1hp0x87bp 10 60086 539858 478568 2026-04-14T18:38:14Z Persino 2851 539858 wikitext text/x-wiki {{#invoke:Ramka|Nazwa=Rozmieniarka|Funkcja=calculateNominals}} <noinclude>{{Dokumentacja}}</noinclude> 6kkd4n3w57p5pq80017pvkxoh23tq18 539859 539858 2026-04-14T18:38:37Z Persino 2851 539859 wikitext text/x-wiki {{#invoke:Ramka|Moduł|Nazwa=Rozmieniarka|Funkcja=calculateNominals}} <noinclude>{{Dokumentacja}}</noinclude> lua0eiqj7y9fucpb4yamyxvg05482q7 539860 539859 2026-04-14T18:41:18Z Persino 2851 539860 wikitext text/x-wiki {{#invoke:Rozmieniarka|calculateNominals}} <noinclude>{{Dokumentacja}}</noinclude> m209n6luazor5oxgye3hqyx2fucik33 828 60188 539905 539797 2026-04-15T11:09:50Z Persino 2851 539905 Scribunto text/plain local p={}; ---- p.znak_127=mw.ustring.char(127); ---- p.tabela_znakowa={ ["|"]="&#"..mw.ustring.byte("|")..";", ["["]="&#"..mw.ustring.byte("[")..";", ["]"]="&#"..mw.ustring.byte("]")..";", ["{"]="&#"..mw.ustring.byte("{")..";", ["}"]="&#"..mw.ustring.byte("}")..";", ["("]="&#"..mw.ustring.byte("(")..";", [")"]="&#"..mw.ustring.byte(")")..";", ["<"]="&#"..mw.ustring.byte("<")..";", [">"]="&#"..mw.ustring.byte(">")..";", ["="]="&#"..mw.ustring.byte("=")..";", ["/"]="&#"..mw.ustring.byte("/")..";", ["\\"]="&#"..mw.ustring.byte("\\")..";", [" "]="&#"..mw.ustring.byte(" ")..";", ["_"]="&#"..mw.ustring.byte("_")..";", ["-"]="&#"..mw.ustring.byte("-")..";", ["`"]="&#"..mw.ustring.byte("`")..";", ["'"]="&#"..mw.ustring.byte("'")..";", ["~"]="&#"..mw.ustring.byte("~")..";", ["!"]="&#"..mw.ustring.byte("!")..";", ["@"]="&#"..mw.ustring.byte("@")..";", ["#"]="&#"..mw.ustring.byte("#")..";", ["$"]="&#"..mw.ustring.byte("$")..";", ["%"]="&#"..mw.ustring.byte("%")..";", ["^"]="&#"..mw.ustring.byte("^")..";", ["&"]="&#"..mw.ustring.byte("&")..";", ["*"]="&#"..mw.ustring.byte("*")..";", ["+"]="&#"..mw.ustring.byte("+")..";", ["\""]="&#"..mw.ustring.byte("\"")..";", [","]="&#"..mw.ustring.byte(",")..";", ["."]="&#"..mw.ustring.byte(".")..";", ["?"]="&#"..mw.ustring.byte("?")..";", [";"]="&#"..mw.ustring.byte(";")..";", [":"]="&#"..mw.ustring.byte(":")..";", ["‎"]="&#"..mw.ustring.byte("‎")..";", }; p.tabela_nawiasowa={ ["{"]="&#"..mw.ustring.byte("{")..";", ["}"]="&#"..mw.ustring.byte("}")..";", ["|"]="&#"..mw.ustring.byte("|")..";", ["="]="&#"..mw.ustring.byte("=")..";", ["<"]="&#"..mw.ustring.byte("<")..";", [">"]="&#"..mw.ustring.byte(">")..";", ["["]="&#"..mw.ustring.byte("[")..";", ["]"]="&#"..mw.ustring.byte("]")..";", ["#"]="&#"..mw.ustring.byte("#")..";", ["?"]="&#"..mw.ustring.byte("?")..";", ["&"]="&#"..mw.ustring.byte("&")..";", [":"]="&#"..mw.ustring.byte(":")..";", ["*"]="&#"..mw.ustring.byte("*")..";", [";"]="&#"..mw.ustring.byte(";")..";", ["!"]="&#"..mw.ustring.byte("!")..";", }; p.kody_literowe_html_i_ich_odpowiedniki_znakowe={ -- Podstawowe ["&lt;"] = "<", ["&gt;"] = ">", ["&amp;"] = "&", ["&quot;"] = "\"", ["&apos;"] = "'", -- Spacje i typografia ["&nbsp;"] = " ", ["&ensp;"] = " ", ["&emsp;"] = " ", ["&thinsp;"] = " ", ["&copy;"] = "©", ["&reg;"] = "®", ["&trade;"] = "™", ["&sect;"] = "§", ["&para;"] = "¶", ["&deg;"] = "°", ["&middot;"] = "·", ["&bull;"] = "•", -- Waluty ["&dollar;"] = "$", ["&cent;"] = "¢", ["&pound;"] = "£", ["&yen;"] = "¥", ["&euro;"] = "€", -- Strzałki ["&larr;"] = "←", ["&uarr;"] = "↑", ["&rarr;"] = "→", ["&darr;"] = "↓", ["&harr;"] = "↔", -- Greckie litery (małe i wielkie) ["&alpha;"] = "α", ["&Alpha;"] = "Α", ["&beta;"] = "β", ["&Beta;"] = "Β", ["&gamma;"] = "γ", ["&Gamma;"] = "Γ", ["&delta;"] = "δ", ["&Delta;"] = "Δ", ["&epsilon;"] = "ε", ["&Epsilon;"] = "Ε", ["&zeta;"] = "ζ", ["&Zeta;"] = "Ζ", ["&eta;"] = "η", ["&Eta;"] = "Η", ["&theta;"] = "θ", ["&Theta;"] = "Θ", ["&iota;"] = "ι", ["&Iota;"] = "Ι", ["&kappa;"] = "κ", ["&Kappa;"] = "Κ", ["&lambda;"] = "λ", ["&Lambda;"] = "Λ", ["&mu;"] = "μ", ["&Mu;"] = "Μ", ["&nu;"] = "ν", ["&Nu;"] = "Ν", ["&xi;"] = "ξ", ["&Xi;"] = "Ξ", ["&omicron;"] = "ο", ["&Omicron;"] = "Ο", ["&pi;"] = "π", ["&Pi;"] = "Π", ["&rho;"] = "ρ", ["&Rho;"] = "Ρ", ["&sigma;"] = "σ", ["&Sigma;"] = "Σ", ["&tau;"] = "τ", ["&Tau;"] = "Τ", ["&upsilon;"] = "υ", ["&Upsilon;"] = "Υ", ["&phi;"] = "φ", ["&Phi;"] = "Φ", ["&chi;"] = "χ", ["&Chi;"] = "Χ", ["&psi;"] = "ψ", ["&Psi;"] = "Ψ", ["&omega;"] = "ω", ["&Omega;"] = "Ω", -- Symbole matematyczne ["&plusmn;"] = "±", ["&times;"] = "×", ["&divide;"] = "÷", ["&infin;"] = "∞", ["&radic;"] = "√", ["&sum;"] = "∑", ["&prod;"] = "∏", ["&int;"] = "∫", ["&forall;"] = "∀", ["&part;"] = "∂", ["&exist;"] = "∃", ["&empty;"] = "∅", ["&nabla;"] = "∇", ["&isin;"] = "∈", ["&notin;"] = "∉", ["&sub;"] = "⊂", ["&sup;"] = "⊃", ["&sube;"] = "⊆", ["&supe;"] = "⊇", ["&oplus;"] = "⊕", ["&otimes;"] = "⊗", ["&perp;"] = "⊥", }; return p; i1llmnytpeuztkoznbjuxk53nrm2pgd 539906 539905 2026-04-15T11:14:34Z Persino 2851 539906 Scribunto text/plain local p={}; ---- p.znak_127=mw.ustring.char(127); ---- p.tabela_znakowa={ ["|"]=mw.ustring.byte("|"), ["["]=mw.ustring.byte("["), ["]"]=mw.ustring.byte("]"), ["{"]=mw.ustring.byte("{"), ["}"]=mw.ustring.byte("}"), ["("]=mw.ustring.byte("("), [")"]=mw.ustring.byte(")"), ["<"]=mw.ustring.byte("<"), [">"]=mw.ustring.byte(">"), ["="]=mw.ustring.byte("="), ["/"]=mw.ustring.byte("/"), ["\\"]=mw.ustring.byte("\\"), [" "]=mw.ustring.byte(" "), ["_"]=mw.ustring.byte("_"), ["-"]=mw.ustring.byte("-"), ["`"]=mw.ustring.byte("`"), ["'"]=mw.ustring.byte("'"), ["~"]=mw.ustring.byte("~"), ["!"]=mw.ustring.byte("!"), ["@"]=mw.ustring.byte("@"), ["#"]=mw.ustring.byte("#"), ["$"]=mw.ustring.byte("$"), ["%"]=mw.ustring.byte("%"), ["^"]=mw.ustring.byte("^"), ["&"]=mw.ustring.byte("&"), ["*"]=mw.ustring.byte("*"), ["+"]=mw.ustring.byte("+"), ["\""]=mw.ustring.byte("\""), [","]=mw.ustring.byte(","), ["."]=mw.ustring.byte("."), ["?"]=mw.ustring.byte("?"), [";"]=mw.ustring.byte(";"), [":"]=mw.ustring.byte(":"), ["‎"]=mw.ustring.byte("‎"), }; p.tabela_nawiasowa={ ["{"]="&#"..mw.ustring.byte("{")..";", ["}"]="&#"..mw.ustring.byte("}")..";", ["|"]="&#"..mw.ustring.byte("|")..";", ["="]="&#"..mw.ustring.byte("=")..";", ["<"]="&#"..mw.ustring.byte("<")..";", [">"]="&#"..mw.ustring.byte(">")..";", ["["]="&#"..mw.ustring.byte("[")..";", ["]"]="&#"..mw.ustring.byte("]")..";", ["#"]="&#"..mw.ustring.byte("#")..";", ["?"]="&#"..mw.ustring.byte("?")..";", ["&"]="&#"..mw.ustring.byte("&")..";", [":"]="&#"..mw.ustring.byte(":")..";", ["*"]="&#"..mw.ustring.byte("*")..";", [";"]="&#"..mw.ustring.byte(";")..";", ["!"]="&#"..mw.ustring.byte("!")..";", }; p.kody_literowe_html_i_ich_odpowiedniki_znakowe={ -- Podstawowe ["&lt;"] = "<", ["&gt;"] = ">", ["&amp;"] = "&", ["&quot;"] = "\"", ["&apos;"] = "'", -- Spacje i typografia ["&nbsp;"] = " ", ["&ensp;"] = " ", ["&emsp;"] = " ", ["&thinsp;"] = " ", ["&copy;"] = "©", ["&reg;"] = "®", ["&trade;"] = "™", ["&sect;"] = "§", ["&para;"] = "¶", ["&deg;"] = "°", ["&middot;"] = "·", ["&bull;"] = "•", -- Waluty ["&dollar;"] = "$", ["&cent;"] = "¢", ["&pound;"] = "£", ["&yen;"] = "¥", ["&euro;"] = "€", -- Strzałki ["&larr;"] = "←", ["&uarr;"] = "↑", ["&rarr;"] = "→", ["&darr;"] = "↓", ["&harr;"] = "↔", -- Greckie litery (małe i wielkie) ["&alpha;"] = "α", ["&Alpha;"] = "Α", ["&beta;"] = "β", ["&Beta;"] = "Β", ["&gamma;"] = "γ", ["&Gamma;"] = "Γ", ["&delta;"] = "δ", ["&Delta;"] = "Δ", ["&epsilon;"] = "ε", ["&Epsilon;"] = "Ε", ["&zeta;"] = "ζ", ["&Zeta;"] = "Ζ", ["&eta;"] = "η", ["&Eta;"] = "Η", ["&theta;"] = "θ", ["&Theta;"] = "Θ", ["&iota;"] = "ι", ["&Iota;"] = "Ι", ["&kappa;"] = "κ", ["&Kappa;"] = "Κ", ["&lambda;"] = "λ", ["&Lambda;"] = "Λ", ["&mu;"] = "μ", ["&Mu;"] = "Μ", ["&nu;"] = "ν", ["&Nu;"] = "Ν", ["&xi;"] = "ξ", ["&Xi;"] = "Ξ", ["&omicron;"] = "ο", ["&Omicron;"] = "Ο", ["&pi;"] = "π", ["&Pi;"] = "Π", ["&rho;"] = "ρ", ["&Rho;"] = "Ρ", ["&sigma;"] = "σ", ["&Sigma;"] = "Σ", ["&tau;"] = "τ", ["&Tau;"] = "Τ", ["&upsilon;"] = "υ", ["&Upsilon;"] = "Υ", ["&phi;"] = "φ", ["&Phi;"] = "Φ", ["&chi;"] = "χ", ["&Chi;"] = "Χ", ["&psi;"] = "ψ", ["&Psi;"] = "Ψ", ["&omega;"] = "ω", ["&Omega;"] = "Ω", -- Symbole matematyczne ["&plusmn;"] = "±", ["&times;"] = "×", ["&divide;"] = "÷", ["&infin;"] = "∞", ["&radic;"] = "√", ["&sum;"] = "∑", ["&prod;"] = "∏", ["&int;"] = "∫", ["&forall;"] = "∀", ["&part;"] = "∂", ["&exist;"] = "∃", ["&empty;"] = "∅", ["&nabla;"] = "∇", ["&isin;"] = "∈", ["&notin;"] = "∉", ["&sub;"] = "⊂", ["&sup;"] = "⊃", ["&sube;"] = "⊆", ["&supe;"] = "⊇", ["&oplus;"] = "⊕", ["&otimes;"] = "⊗", ["&perp;"] = "⊥", }; return p; dkufldzvtfd9qayprdu9n6n7mrznmie 4 60365 539863 518895 2026-04-14T18:46:34Z Persino 2851 /* Szablony specjalistyczne podręcznikowe */ 539863 wikitext text/x-wiki <noinclude>{{Autonawigacja|Pomoc:Spis treści}}</noinclude> == Szablony tematyczne ogólne do wykorzystania w podręcznikach == {{EfektKodów|kod-rozmiar=50% | 1 = {{Pre|{{s|SzachyDiagram|d{{=}} | prawo | '''W. Langstaff''', ''Chess Amateur'' 1922 |{{=}} 8 | | | | |kd| | |rd|w8{{=}} 7 | | | | | | | | |w7{{=}} 6 | | | | | |bl| |pl|w6{{=}} 5 | | | |rl| |kl|pd|pl|w5{{=}} 4 | | | | | | | | |w4{{=}} 3 | | | | | | | | |w3{{=}} 2 | | | | | | | | |w2{{=}} 1 | | | | | | | | |w1{{=}} a b c d e f g h | '''Dopasuj na dwoje.''' <br /> Ten problem wykorzystuje metodę ''częściowej analizy wstecznej''. }} }} | _1 = {{SzachyDiagram|d= | prawo | '''W. Langstaff''', ''Chess Amateur'' 1922 |= 8 | | | | |kd| | |rd|w8= 7 | | | | | | | | |w7= 6 | | | | | |bl| |pl|w6= 5 | | | |rl| |kl|pd|pl|w5= 4 | | | | | | | | |w4= 3 | | | | | | | | |w3= 2 | | | | | | | | |w2= 1 | | | | | | | | |w1= a b c d e f g h | '''Dopasuj na dwoje.''' <br /> Ten problem wykorzystuje metodę ''częściowej analizy wstecznej''. }} | 2 = {{Pre| {{s|SzachyDiagramMały|d{{=}} | prawo | |{{=}} 8 |rd| | |qd| |rd|kd| |w8{{=}} 7 |pd|pd| | |pd|pd|bd|pd|w7{{=}} 6 | |nd|pd| | |nd|pd| |w6{{=}} 5 | | |ql| | | |bl| |w5{{=}} 4 | | | |pl|pl| |bd| |w4{{=}} 3 | | |nl| | |nl| | |w3{{=}} 2 |pl|pl| | | |pl|pl|pl|w2{{=}} 1 | | | |rl|kl|bl| |rl|w1{{=}} a b c d e f g h | Pozycja po 11. Gg5. }} }} | _2 = {{SzachyDiagramMały|d= | prawo | |= 8 |rd| | |qd| |rd|kd| |w8= 7 |pd|pd| | |pd|pd|bd|pd|w7= 6 | |nd|pd| | |nd|pd| |w6= 5 | | |ql| | | |bl| |w5= 4 | | | |pl|pl| |bd| |w4= 3 | | |nl| | |nl| | |w3= 2 |pl|pl| | | |pl|pl|pl|w2= 1 | | | |rl|kl|bl| |rl|w1= a b c d e f g h | Pozycja po 11. Gg5. }} }} == Ramki podręcznikowe informujące == Przedstawia wszystkie pudełka informacyjne, do których wstawia się tekst ich zawartości. === Szablony bibliografii === {{EfektKodów|kod-rozmiar=35% | 1 = {{Tt|{{s|BibliografiaOpracowania|Tekst bibliografii opracowań}}}} | _1 = {{BibliografiaOpracowania|Tekst bibliografii opracowań}} | 2 = {{Tt|{{s|BibliografiaŹródła|Tekst bibliografii źródeł}}}} | _2 = {{BibliografiaŹródła|Tekst bibliografii źródeł}} }} === Szablony do zastosowań mniej ogólnych === {{EfektKodów | 1 = {{Tt|{{s|System|starszego od Ubuntu 10.04|w późniejszych}}}} | _1 = {{System|starszego od Ubuntu 10.04|w późniejszych}} | 2 = {{Tt|{{s|Wymaga znajomości|Struktury danych}}}} | _2 = {{Wymaga znajomości|Struktury danych}} }} === Szablony do zastosowań szczególnych (tematyczne) === Przedstawia szablony do różnych dziedzin nauki do różnych jego aspektów. ==== Szablony matematyczne ==== {{EfektKodów|kod-rozmiar=35% | 1 = {{Tt|{{s|Mat:Ciek|Jeśli liczba jest <nowiki>'''</nowiki>większa od 0<nowiki>'''</nowiki>, to nie jest <nowiki>'''</nowiki>liczbą ujemną<nowiki>'''</nowiki>.}}}} | _1 = {{Mat:Ciek|Jeśli liczba jest '''większa od 0''', to nie jest '''liczbą ujemną'''.}} | 2 = {{Tt|{{s|Mat:Def|<nowiki>'''</nowiki>Liczbę dodatnią<nowiki>'''</nowiki> nazywamy taką liczbę, która jest większa od 0.}}}} | _2 = {{Mat:Def|'''Liczbę dodatnią''' nazywamy taką liczbę, która jest większa od 0.}} | 3 = {{Tt|{{s|Mat:Tw|Jeśli liczba jest <nowiki>'''</nowiki>większa od 0<nowiki>'''</nowiki>, to jest <nowiki>'''</nowiki>liczbą dodatnią<nowiki>'''</nowiki>.}}}} | _3 = {{Mat:Tw|Jeśli liczba jest '''większa od 0''', to jest '''liczbą dodatnią'''.}} | 4 = {{Tt|{{s|Mat:Prz|Jeśli liczba jest <nowiki>'''</nowiki>większa od 0<nowiki>'''</nowiki>, to jest <nowiki>'''</nowiki>liczbą dodatnią<nowiki>'''</nowiki>.}}}} |_4 = {{Mat:Prz|Jeśli liczba jest '''większa od 0''', to jest '''liczbą dodatnią'''.}} | 5 = {{Tt|{{s|Mat:Uwg|Jeśli liczba jest <nowiki>'''</nowiki>większa od 0<nowiki>'''</nowiki>, to jest <nowiki>'''</nowiki>liczbą dodatnią<nowiki>'''</nowiki>.}}}} |_5 = {{Mat:Uwg|Jeśli liczba jest '''większa od 0''', to jest '''liczbą dodatnią'''.}} }} ==== Szablony matematyczno-fizyczne ==== {{EfektKodów|kod-rozmiar=35% | 1 = {{Tt|{{s|DefinicjaHasło|hasło{{=}}Prędkość|tekst{{=}}Prędkość ciała jest wielkością fizyczną, która charakteryzuje ruch ciała w danej chwili, czyli jest to stosunek przemieszczenia do czasu w którym zachodzi to przemieszczenie.<nowiki><br><center><MATH>\vec v = \frac {\Delta \vec r}{\Delta t}</MATH> <MATH> \left[ \vec v\right] = \frac {m}{s} </MATH><br></center></nowiki>}}}} | _1 = {{DefinicjaHasło|hasło=Prędkość|tekst=Prędkość ciała jest wielkością fizyczną, która charakteryzuje ruch ciała w danej chwili, czyli jest to stosunek przemieszczenia do czasu w którym zachodzi to przemieszczenie.<br><center><MATH>\vec v = \frac {\Delta \vec r}{\Delta t}</MATH> <MATH> \left[ \vec v\right] = \frac {m}{s} </MATH><br></center>}} | 2 = {{Tt|{{s|PrawoHasło|hasło{{=}}Prawo Ohma|tekst{{=}}Natężenie prądu elektrycznego płynącego przez przewodnik jest wprost proporcjonalne do napięcia przyłożonego do końców tego przewodnika, a odwrotnie proporcjonalnie do oporu tego przewodnika.<nowiki><center><MATH>I = \frac {U}{R}</MATH><br></center></nowiki>}}}} | _2 = {{PrawoHasło|hasło=Prawo Ohma|tekst=Natężenie prądu elektrycznego płynącego przez przewodnik jest wprost proporcjonalne do napięcia przyłożonego do końców tego przewodnika, a odwrotnie proporcjonalnie do oporu tego przewodnika.<center><MATH>I = \frac {U}{R}</MATH><br></center>}} | 3 = {{Tt|{{s|PrzykładTemat|temat{{=}}Źródło światła|treść{{=}}Najprostszym źródłem światła, używanym na codzień, jest żarówka z żarnikiem wolframowym.}}}} | _3 = {{PrzykładTemat|temat=Źródło światła|treść=Najprostszym źródłem światła, używanym na codzień, jest żarówka z żarnikiem wolframowym.}} | 4 = {{Tt|{{s|MateriałTemat|matematyka{{=}}pojęcie wektora<nowiki><br></nowiki>rachunek wektorowy<nowiki><br></nowiki>|fizyka{{=}}definicja prędkości}}}} | _4 = {{MateriałTemat|matematyka=pojęcie wektora<br>rachunek wektorowy<br>|fizyka=definicja prędkości}} | 5 = {{Tt|{{s|ZadanieTemat|temat{{=}}Ruch prostoliniowy|treść{{=}}Punkt materialny porusza się ruchem jednostajnym prostoliniowym z prędkością <nowiki><MATH>5{{m}\over{s}}</MATH></nowiki>.|pytanie{{=}}Jaką drogę ciało przebyło w czasie 2s.|rozwiązanie{{=}}<nowiki><MATH>s=vt=5{{m}\over{s}}\cdot 2s=10m</MATH></nowiki>.|odpowiedź{{=}}Ciało przebyło drogę <nowiki><MATH>10m</MATH></nowiki>.}}}} | _5 = {{ZadanieTemat|temat=Ruch prostoliniowy|treść=Punkt materialny porusza się ruchem jednostajnym prostoliniowym z prędkością <MATH>5{{m}\over{s}}</MATH>.|pytanie=Jaką drogę ciało przebyło w czasie 2s.|rozwiązanie=<MATH>s=vt=5{{m}\over{s}}\cdot 2s=10m</MATH>.|odpowiedź=Ciało przebyło drogę <MATH>10m</MATH>.}} }} ==== Szablony ekonomiczne ==== {{EfektKodów|kod-rozmiar=35% | 1= {{Pre start}} {{s|Tabela|klasa{{=}}konta|liczba wierszy{{=}}1|liczba kolumn{{=}}3 |komórka 1_1{{=}}{{s|Konto otwórz|070|Umorzenie środków trwałych}} {{s|Konto zapis|Ma|1|3256,00}} {{s|Konto zapis|Ma|2|3250,00|Wn|3|3260,0}} {{s|Konto zamknij}} |komórka 1_2{{=}}{{s|Konto otwórz|400|Amortyzacja}} {{s|Konto zapis|Wn|1|4250,00|Ma|2|3250,00}} {{s|Konto zapis|Wn|3|2200,00|Ma|4|3750,00}} {{s|Konto zamknij}} |komórka 1_3{{=}}{{s|Konto otwórz|075|Umorzenie wartości niematerialnych i prawnych}} {{s|Konto zapis|Ma|1|2200,00|Wn|2|4590,0}} {{s|Konto zapis|Ma|3|2200,00}} {{s|Konto zapis|Wn|4|5590,0}} {{s|Konto zamknij}} }} {{Pre koniec}} | _1= {{Tabela|klasa=konta|liczba wierszy=1|liczba kolumn=3 |komórka 1_1={{Konto otwórz|070|Umorzenie środków trwałych}} {{Konto zapis|Ma|1|3256,00}} {{Konto zapis|Ma|2|3250,00|Wn|3|3260,0}} {{Konto zamknij}} |komórka 1_2={{Konto otwórz|400|Amortyzacja}} {{Konto zapis|Wn|1|4250,00|Ma|2|3250,00}} {{Konto zapis|Wn|3|2200,00|Ma|4|3750,00}} {{Konto zamknij}} |komórka 1_3={{Konto otwórz|075|Umorzenie wartości niematerialnych i prawnych}} {{Konto zapis|Ma|1|2200,00|Wn|2|4590,0}} {{Konto zapis|Ma|3|2200,00}} {{Konto zapis|Wn|4|5590,0}} {{Konto zamknij}} }} }} ==== Szablony chemiczne ==== {{EfektKodów|kod-rozmiar=35% | 1= {{Pre|{{s|Chem:ciek|Tytuł{{=}}Kwas dymiący.|Treść ciekawostki{{=}}Kwas dymiący. Dym, unoszący się z naczynia ze stężonym kwasem solnym, to drobne kropelki tego kwasu. Chlorowodór, który wydostaje się z naczynia, łączy się z parą wodną z powietrza, tworząc kwas. Przy niższych stężeniach (poniżej 30%) dym nie tworzy się.}}}} | _1= {{Chem:ciek|Tytuł=Kwas dymiący.|Treść ciekawostki=Kwas dymiący. Dym, unoszący się z naczynia ze stężonym kwasem solnym, to drobne kropelki tego kwasu. Chlorowodór, który wydostaje się z naczynia, łączy się z parą wodną z powietrza, tworząc kwas. Przy niższych stężeniach (poniżej 30%) dym nie tworzy się.}} | 2 = {{Pre|{{s|Chem:dośw|Nazwa doświadczenia{{=}}Otrzymywanie kwasu solnego.|Do próbówki z chlorowodorem nalać wody z oranżem metylowym. Zatkać próbówkę korkiem i wstrząsnąć.|Woda z oranżem metylowym zabarwiła się na czerwono.|Chlorowodór rozpuszcza się w wodzie, tworząc kwas chlorowodorowy (solny).}}}} | _2 = {{Chem:dośw|Nazwa doświadczenia=Otrzymywanie kwasu solnego.|Do próbówki z chlorowodorem nalać wody z oranżem metylowym. Zatkać próbówkę korkiem i wstrząsnąć.|Woda z oranżem metylowym zabarwiła się na czerwono.|Chlorowodór rozpuszcza się w wodzie, tworząc kwas chlorowodorowy (solny).}} }} == Testy według pewnych możliwości wyboru według różnych schematów == {{EfektKodów | 1 = {{Pre|{{s|Test ABCD| |Zadanie{{=}}Zadanie 1. Tlenek azotu (I) |A{{=}}jest bezbarwnym gazem|B{{=}}ma wzór sumaryczny {{s|Chem2|NO}}|C{{=}}reaguje z wodą|D{{=}}jest mało reaktywny |odpowiedź{{=}}a) jest bezbarwnym gazem{{s|Br}}d) jest mało reaktywny|uwagi{{=}}}} }} | _1 = {{Test ABCD| |Zadanie=Zadanie 1. Tlenek azotu (I) |A=jest bezbarwnym gazem|B=ma wzór sumaryczny {{Chem2|NO}}|C=reaguje z wodą|D=jest mało reaktywny |odpowiedź=a) jest bezbarwnym gazem<br>d) jest mało reaktywny|uwagi=}} | 2 = {{Pre|{{s|Quiz-odpowiedź| * gleby * zbiorniki wody słodkiej * morza i oceany * w ciałach innych organizmów * w środowiskach ekstremalnych}}}} | _2 = {{Quiz-odpowiedź| * gleby * zbiorniki wody słodkiej * morza i oceany * w ciałach innych organizmów * w środowiskach ekstremalnych}} | 3 = {{Pre|{{s|Test PF| |Zadanie{{=}}Zadanie 1. : |odpowiedź{{=}}F |uwagi{{=}}}} }} | _3 = {{Test PF| |Zadanie=Zadanie 1. : |odpowiedź=F |uwagi=}} | 4 = {{Pre|{{s|Test TN| |Zadanie{{=}}Zadanie 4. Czy kambium umożliwia wzrost łodygi oraz korzenia na grubość? |odpowiedź{{=}}T |uwagi{{=}}}} }} | _4 = {{Test TN| |Zadanie=Zadanie 4. Czy kambium umożliwia wzrost łodygi oraz korzenia na grubość? |odpowiedź=T |uwagi=}} }} === Szablony zadań === {{EfektKodów|kod-rozmiar=40% | 1 = {{Pre|styl=min-width:800px| {{s|Klucz odpowiedzi CKE | cele {{=}} {{s|T|PP2017/LO/Biologia/PR/C/III/2}} | treści {{=}} {{s|T|PP2017/LO/Biologia/PR/T/XII/1/4}} | zasady {{=}} {{s|f|wys{{=}}38px|1 p. – za prawidłowe podanie ostatniego etapu cyklu litycznego}} {{s|f|wys{{=}}38px|0 p. – za nieprawidłowe podanie ostatniego etapu cyklu litycznego albo za brak odpowiedzi}} | rozwiązania {{=}} '''A.''' wyciek cytoplazmy do środowiska | uwagi {{=}} }} }} | _1 = {{Div|styl=min-width:800px|{{OpakujKategorieZeSortowaniem|{{Klucz odpowiedzi CKE |cele = {{T|PP2017/LO/Biologia/PR/C/III/2}} |treści = {{T|PP2017/LO/Biologia/PR/T/XII/1/4}} |zasady = {{f|wys=38px|1 p. – za prawidłowe podanie ostatniego etapu cyklu litycznego}} {{f|wys=38px|0 p. – za nieprawidłowe podanie ostatniego etapu cyklu litycznego albo za brak odpowiedzi}} |rozwiązania = '''A.''' wyciek cytoplazmy do środowiska |uwagi = }}}}}} | 2 = {{Tt|{{s|Nowe zadanie maturalne}}}} | _2 = {{Nowe zadanie maturalne}} }} == Niezgodność ze współczesną wiedzą naukową == {{EfektKodów|kod-rozmiar=35% | 1 = {{Tt|{{s|Nmed|sekcja{{=}}tak}}}} | _1 = {{OpakujKategorieZeSortowaniem|{{Nmed|sekcja=tak|nazwa przestrzeni nazw=(main)|typ jednostki=artykuł}}}} }} == Szablony podręcznikowe tymczasowo wstawiony stronę artykułu książki == {{EfektKodów | 1 = {{Tt|{{s|Aktualne|link{{=}}Portal:Katastrofa polskiego samolotu prezydenckiego pod Smoleńskiem}}}} | _1 = {{OpakujKategorieZeSortowaniem|{{Aktualne|link=Portal:Katastrofa polskiego samolotu prezydenckiego pod Smoleńskiem|typ jednostki=artykuł}}}} }} == Szablony specjalistyczne podręcznikowe == {{EfektKodów | 1 = {{Tt|{{s|Rozmieniarka|kwota{{=}}1000|500zł{{=}}1|200zł{{=}}2|5zł{{=}}50}}}} | _1 = {{Rozmieniarka|kwota=1000|500zł=1|200zł=2|5zł=50}} }} == Szablony elementów pływających == {{EfektKodów | 1 = {{Pre|styl=min-width:800px|{{s|Naukowiec | Imię_nazwisko {{=}} Linus Carl Pauling | Grafika {{=}} {{s|Plik|plik{{=}}Pauling.jpg|pozycja{{=}}centruj|rozmiar{{=}}80px}} | data_miejsce_ur {{=}} 28 lutego 1901 w Portland w stanie Oregon | data_miejsce_śm {{=}} 19 sierpnia 1994 w Big Sur w stanie Kalifornia | info {{=}} Po ukończeniu studiów na Oregon State University otrzymał doktorat w California Institute of Technology w 1925. W latach 1925 - 1967 profesor chemii na tym uniwersytecie. Dokonał odkryć w dziedzinie wiązań chemicznych, biologii molekularnej i medycyny. | nobel_data {{=}} 1954 - chemia, za prace nad wiązaniami chemicznymi i ich zastosowanie w wyjaśnieniu budowy związków kompleksowych<br>1962 - nagroda pokojowa, za kampanię przeciw próbom z bronią jądrową | nobel {{=}} tak }} {{s|Lorem ipsum|6}} }} | _1 = {{Div|styl=min-width:800px|{{Naukowiec | Imię_nazwisko=Linus Carl Pauling | Grafika = {{Plik|plik=Pauling.jpg|pozycja=centruj|rozmiar=80px}} | data_miejsce_ur = 28 lutego 1901 w Portland w stanie Oregon | data_miejsce_śm = 19 sierpnia 1994 w Big Sur w stanie Kalifornia | info = Po ukończeniu studiów na Oregon State University otrzymał doktorat w California Institute of Technology w 1925. W latach 1925 - 1967 profesor chemii na tym uniwersytecie. Dokonał odkryć w dziedzinie wiązań chemicznych, biologii molekularnej i medycyny. | nobel_data = 1954 - chemia, za prace nad wiązaniami chemicznymi i ich zastosowanie w wyjaśnieniu budowy związków kompleksowych<br>1962 - nagroda pokojowa, za kampanię przeciw próbom z bronią jądrową | nobel = tak }} {{Lorem ipsum|6}} {{BrClear}} }}}} == Szablony arkuszy kalkulacyjne == {{EfektKodów | 1 = {{Tt|{{s|Oblicz-przykład| formuła | wynik | w innej mierze }}}} | _1 = {{Oblicz-przykład| formuła | wynik | w innej mierze }} | 2 = {{Tt|{{s|Oblicz-arkusz|A1{{=}}1|A2{{=}}2|A3{{=}}3|C2{{=}} {{=}}SUMA(A1:A3)|D2{{=}}6}}}} | _2 = {{Oblicz-arkusz|A1=1|A2=2|A3=3|C2= =SUMA(A1:A3)|D2=6}} }} == Szablony internetowej pomocy systemowej {{lpg|Man}} == {{EfektKodów | 1 = {{Tt|{{s|Man|1|man|FreeBSD}}}} | _1 = {{Man|1|man|FreeBSD}} | 2 = {{Tt|{{s|PosixMan|pthread_create|int pthread_create(pthread_t *id, const pthread_attr_t *attr, void* (*fun)(void*), void* arg)}}}} | _2 = {{PosixMan|pthread_create|int pthread_create(pthread_t *id, const pthread_attr_t *attr, void* (*fun)(void*), void* arg)}} | 3 = {{Tt|{{s|KernelMan|3|pthread_setaffinity_np}}}} | _3 = {{KernelMan|3|pthread_setaffinity_np}} }} == Szablony kodowania znaków {{lpg|Unicode}} == {{EfektKodów | 1 = {{Tt|{{s|UC|05F0|1520|D7 B0|}}}} | _1 = {{UC|05F0|1520|D7 B0|}} | 2 = {{Tt|{{s|UC/ref1|059B|HEBREW ACCENT TEVIR|}}}} | _2 = {{UC/ref1|059B|HEBREW ACCENT TEVIR|}} | 3 = {{Tt|{{s|UC/ref2|05AA|HEBREW ACCENT YERAH BEN YOMO}}}} | _3 = {{UC/ref2|05AA|HEBREW ACCENT YERAH BEN YOMO}} | 4 = {{Tt|{{s|UC/combining|05F0}}}} | _4 = {{UC/combining|05F0}} | 5 = {{Tt|{{s|UC/visual|x05F0}}}} | _5 = {{UC/visual|x05F0}} }} {{BrClear}} <noinclude>{{Kategoria|Wizualne opisy techniczne szablonów}}</noinclude> cse3nhywtr3gpu7ohyrazj0fomembia 10 60707 539867 495212 2026-04-14T19:03:28Z Persino 2851 /* Przykład */ 539867 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Rozmieniarka}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{Rozmieniarka|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->|wyspecjalizowana=tak}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{Rozmieniarka|kwota=123.45|10zł=2|0.2zł=5|wyspecjalizowana=tak}} lub inaczej: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} </syntaxhighlight> * Wynik: {{Rozmieniarka|kwota=123.45|10zł=2|20gr=5|wyspecjalizowana=tak}} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> lw729gdtkwddmdfvt65x4ul55j59gwj 539868 539867 2026-04-14T19:03:56Z Persino 2851 /* Przykład */ 539868 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Rozmieniarka}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == Przykładowe użycie w wikikodzie, używając pierwszy parametr jako {{Code|kwota}}, a następny, ile jest danego nominału dla danego numerka: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} </syntaxhighlight> * Wynik: {{Rozmieniarka|1=123.45|7=2<!-- nominał 10-->|12=5<!--nominał 0.2-->}} lub bezpośrednio używając parametry {{Code|kwota}} i nominałów: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|kwota=123.45|10zł=2|0.2zł=5}} </syntaxhighlight> * Wynik: {{Rozmieniarka|kwota=123.45|10zł=2|0.2zł=5}} lub inaczej: <syntaxhighlight lang=mediawiki> {{Rozmieniarka|kwota=123.45|10zł=2|20gr=5}} </syntaxhighlight> * Wynik: {{Rozmieniarka|kwota=123.45|10zł=2|20gr=5}} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> </includeonly> 12llr7ogaztfiflgesg3xe0d4rwum89 4 63007 539821 538760 2026-04-14T14:26:26Z Persino 2851 /* Funkcje subnazw, nawet książkowe */ 539821 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw książkowe == === Funkcje nazw książki === ==== {{Code|m["NAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, bez przestrzeni nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}, a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż|użytkownik}}}}, gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local nazwa_ksiazki_1=nazwy_modul["NAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_ksiazki_2=nazwy_modul["NAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka: local nazwa_ksiazki_3=nazwy_modul["NAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_4=nazwy_modul["NAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_5=nazwy_modul["NAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAKSIĄŻKI}}: * {{Code|{{s|NAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, z przestrzenią nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a z tą przestrznia nazw {{Code|Wikibooks'a}}, jedynie dla tej drugiej jest ciągiem niepustym, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki, z przestrzeniami projektu, jest: {{Code|{{lr2|Brudnopis/użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}), a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż2|użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lż|użytkownik}}}}), gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local pelna_nazwa_ksiazki_1=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior:Książka": local pelna_nazwa_ksiazki_2=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_3=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_4=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_5=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} === Funkcje nazw artykułów === ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości: "". <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Gdy nazwa artykułu jest równa stronie głównej podręcznika * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI2"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI2}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości równej nazwie sub-książki, czyli bez przestrzeni książki i projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł: local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI2}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["PEŁNANAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jego adres z nazwą sub-książki. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_1=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_2=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_3=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_4=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_5=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_6=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_7=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_8=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_9=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_10=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} === Przestrzenie książki w przestrzeniach nazw książkowych === ==== {{Code|m["NAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_1=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_2=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_3=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_4=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_5=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local pelna_nazwa_przestrzeni_ksiazki_1=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior": local pelna_nazwa_przestrzeni_ksiazki_2=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_3=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_4=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_5=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje subnazw, nawet książkowe == === {{Code|m.NAZWASUBPODSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBPODSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Posługuje się nazwą strony bezpośrednio w stanie surowym bez przekształcania inną funkcją w samej swojej definicji, ale można ręcznie przekształcać tę nazwę, podając odpowiednio w jej parametr. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBPODSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBPODSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m.NAZWASUBSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. Jest bardzo podobna do szablonu {{s|NAZWASUBPODSTRONY}}. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Korzysta z funkcji {{Code|{{sr|#m.NAZWASUBPODSTRONY()|p=Nazwy - Tom IV}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["SUBNAZWAKSIĄŻKI"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|SUBNAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon wyodrębnia z pełnej nazwy artykułu nazwę sub-książki, do której należy ten artykuł. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw i przestrzeni nazw książki: ---- Zwraca wynik: "Książka": local nazwa_subksiazki_1=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_2=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_3=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_4=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_5=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|SUBNAZWAKSIĄŻKI}}: * {{Code|{{s|SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje nazw korzeni stron == === {{Code|m.NAZWAKORZENIASTRONY()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWAKORZENIASTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona": local nazwa_substrony_2 = nazwy_modul.NAZWAKORZENIASTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu: * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["PEŁNANAZWAKORZENIASTRONY"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_2 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_2,tabela_nazw_2); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu: * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> h901d62w1qflo5b3iy0lm99lr66d81h 539822 539821 2026-04-14T14:29:58Z Persino 2851 /* Funkcja biblioteczna */ 539822 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw książkowe == === Funkcje nazw książki === ==== {{Code|m["NAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, bez przestrzeni nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}, a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż|użytkownik}}}}, gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local nazwa_ksiazki_1=nazwy_modul["NAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_ksiazki_2=nazwy_modul["NAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka: local nazwa_ksiazki_3=nazwy_modul["NAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_4=nazwy_modul["NAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_5=nazwy_modul["NAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAKSIĄŻKI}}: * {{Code|{{s|NAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, z przestrzenią nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a z tą przestrznia nazw {{Code|Wikibooks'a}}, jedynie dla tej drugiej jest ciągiem niepustym, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki, z przestrzeniami projektu, jest: {{Code|{{lr2|Brudnopis/użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}), a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż2|użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lż|użytkownik}}}}), gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local pelna_nazwa_ksiazki_1=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior:Książka": local pelna_nazwa_ksiazki_2=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_3=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_4=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_5=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} === Funkcje nazw artykułów === ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości: "". <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Gdy nazwa artykułu jest równa stronie głównej podręcznika * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI2"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI2}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości równej nazwie sub-książki, czyli bez przestrzeni książki i projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł: local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI2}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["PEŁNANAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jego adres z nazwą sub-książki. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_1=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_2=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_3=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_4=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_5=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_6=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_7=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_8=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_9=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_10=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} === Przestrzenie książki w przestrzeniach nazw książkowych === ==== {{Code|m["NAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_1=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_2=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_3=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_4=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_5=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local pelna_nazwa_przestrzeni_ksiazki_1=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior": local pelna_nazwa_przestrzeni_ksiazki_2=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_3=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_4=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_5=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje subnazw, nawet książkowe == === {{Code|m.NAZWASUBPODSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBPODSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, z przestrzenią nazw, jeżeli nazwa strony jest równa pełnej stronie korzenia strony, w innych przypadkach ona działa podobnie jak funkcja: {{Code|{{sr|#NAZWASUBSTRONY|p=Nazwy - Tom IV}}}}. Posługuje się nazwą strony bezpośrednio w stanie surowym bez przekształcania inną funkcją w samej swojej definicji, ale można ręcznie przekształcać tę nazwę, podając odpowiednio w jej parametr. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBPODSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBPODSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m.NAZWASUBSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. Jest bardzo podobna do szablonu {{s|NAZWASUBPODSTRONY}}. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Korzysta z funkcji {{Code|{{sr|#m.NAZWASUBPODSTRONY()|p=Nazwy - Tom IV}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["SUBNAZWAKSIĄŻKI"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|SUBNAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon wyodrębnia z pełnej nazwy artykułu nazwę sub-książki, do której należy ten artykuł. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw i przestrzeni nazw książki: ---- Zwraca wynik: "Książka": local nazwa_subksiazki_1=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_2=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_3=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_4=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_5=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|SUBNAZWAKSIĄŻKI}}: * {{Code|{{s|SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje nazw korzeni stron == === {{Code|m.NAZWAKORZENIASTRONY()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWAKORZENIASTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona": local nazwa_substrony_2 = nazwy_modul.NAZWAKORZENIASTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu: * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["PEŁNANAZWAKORZENIASTRONY"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_2 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_2,tabela_nazw_2); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu: * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ahlu4xizto4y0mmbzfqc7zzhazl3ekp 539823 539822 2026-04-14T14:31:42Z Persino 2851 /* Funkcja biblioteczna */ 539823 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw książkowe == === Funkcje nazw książki === ==== {{Code|m["NAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, bez przestrzeni nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}, a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż|użytkownik}}}}, gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local nazwa_ksiazki_1=nazwy_modul["NAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_ksiazki_2=nazwy_modul["NAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka: local nazwa_ksiazki_3=nazwy_modul["NAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_4=nazwy_modul["NAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_5=nazwy_modul["NAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAKSIĄŻKI}}: * {{Code|{{s|NAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, z przestrzenią nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a z tą przestrznia nazw {{Code|Wikibooks'a}}, jedynie dla tej drugiej jest ciągiem niepustym, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki, z przestrzeniami projektu, jest: {{Code|{{lr2|Brudnopis/użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}), a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż2|użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lż|użytkownik}}}}), gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local pelna_nazwa_ksiazki_1=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior:Książka": local pelna_nazwa_ksiazki_2=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_3=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_4=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_5=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} === Funkcje nazw artykułów === ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości: "". <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Gdy nazwa artykułu jest równa stronie głównej podręcznika * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI2"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI2}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości równej nazwie sub-książki, czyli bez przestrzeni książki i projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł: local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI2}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["PEŁNANAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jego adres z nazwą sub-książki. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_1=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_2=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_3=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_4=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_5=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_6=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_7=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_8=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_9=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_10=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} === Przestrzenie książki w przestrzeniach nazw książkowych === ==== {{Code|m["NAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_1=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_2=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_3=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_4=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_5=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local pelna_nazwa_przestrzeni_ksiazki_1=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior": local pelna_nazwa_przestrzeni_ksiazki_2=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_3=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_4=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_5=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje subnazw, nawet książkowe == === {{Code|m.NAZWASUBPODSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBPODSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, z przestrzenią nazw, jeżeli nazwa strony jest równa pełnej stronie korzenia strony, w innych przypadkach ona działa podobnie jak funkcja: {{Code|{{sr|#NAZWASUBSTRONY|p=Nazwy - Tom IV}}}}. Posługuje się nazwą strony bezpośrednio w stanie surowym bez przekształcania inną funkcją w samej swojej definicji, ale można ręcznie przekształcać tę nazwę, podając odpowiednio w jej parametr. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBPODSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBPODSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m.NAZWASUBSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. Jest bardzo podobna do szablonu {{s|NAZWASUBPODSTRONY}}. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Korzysta z funkcji {{Code|{{sr|#m.NAZWASUBPODSTRONY()|p=Nazwy - Tom IV}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["SUBNAZWAKSIĄŻKI"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|SUBNAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon wyodrębnia z pełnej nazwy artykułu nazwę sub-książki, do której należy ten artykuł. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw i przestrzeni nazw książki: ---- Zwraca wynik: "Książka": local nazwa_subksiazki_1=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_2=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_3=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_4=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_5=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|SUBNAZWAKSIĄŻKI}}: * {{Code|{{s|SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje nazw korzeni stron == === {{Code|m.NAZWAKORZENIASTRONY()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWAKORZENIASTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona": local nazwa_substrony_2 = nazwy_modul.NAZWAKORZENIASTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu: * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["PEŁNANAZWAKORZENIASTRONY"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_2 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_2,tabela_nazw_2); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu: * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hsqhrxfx2wrnzp2sah32h024zp7h870 539824 539823 2026-04-14T15:19:52Z Persino 2851 /* Funkcja biblioteczna */ 539824 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw książkowe == === Funkcje nazw książki === ==== {{Code|m["NAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, bez przestrzeni nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}, a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż|użytkownik}}}}, gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local nazwa_ksiazki_1=nazwy_modul["NAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_ksiazki_2=nazwy_modul["NAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka: local nazwa_ksiazki_3=nazwy_modul["NAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_4=nazwy_modul["NAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_5=nazwy_modul["NAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAKSIĄŻKI}}: * {{Code|{{s|NAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, z przestrzenią nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a z tą przestrznia nazw {{Code|Wikibooks'a}}, jedynie dla tej drugiej jest ciągiem niepustym, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki, z przestrzeniami projektu, jest: {{Code|{{lr2|Brudnopis/użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}), a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż2|użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lż|użytkownik}}}}), gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local pelna_nazwa_ksiazki_1=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior:Książka": local pelna_nazwa_ksiazki_2=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_3=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_4=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_5=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} === Funkcje nazw artykułów === ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości: "". <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Gdy nazwa artykułu jest równa stronie głównej podręcznika * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI2"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI2}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości równej nazwie sub-książki, czyli bez przestrzeni książki i projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł: local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI2}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["PEŁNANAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jego adres z nazwą sub-książki. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_1=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_2=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_3=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_4=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_5=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_6=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_7=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_8=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_9=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_10=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} === Przestrzenie książki w przestrzeniach nazw książkowych === ==== {{Code|m["NAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_1=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_2=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_3=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_4=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_5=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local pelna_nazwa_przestrzeni_ksiazki_1=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior": local pelna_nazwa_przestrzeni_ksiazki_2=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_3=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_4=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_5=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje subnazw, nawet książkowe == === {{Code|m.NAZWASUBPODSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBPODSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, z przestrzenią nazw, jeżeli nazwa strony jest równa pełnej stronie korzenia strony, w innych przypadkach ona działa podobnie jak funkcja: {{Code|{{sr|#m.NAZWASUBSTRONY|p=Nazwy - Tom IV}}}}. Posługuje się nazwą strony bezpośrednio w stanie surowym bez przekształcania inną funkcją w samej swojej definicji, ale można ręcznie przekształcać tę nazwę, podając odpowiednio w jej parametr. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBPODSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBPODSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m.NAZWASUBSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. Jest bardzo podobna do szablonu {{s|NAZWASUBPODSTRONY}}. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Korzysta z funkcji {{Code|{{sr|#m.NAZWASUBPODSTRONY()|p=Nazwy - Tom IV}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["SUBNAZWAKSIĄŻKI"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|SUBNAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon wyodrębnia z pełnej nazwy artykułu nazwę sub-książki, do której należy ten artykuł. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw i przestrzeni nazw książki: ---- Zwraca wynik: "Książka": local nazwa_subksiazki_1=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_2=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_3=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_4=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_5=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|SUBNAZWAKSIĄŻKI}}: * {{Code|{{s|SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje nazw korzeni stron == === {{Code|m.NAZWAKORZENIASTRONY()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWAKORZENIASTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona": local nazwa_substrony_2 = nazwy_modul.NAZWAKORZENIASTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu: * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["PEŁNANAZWAKORZENIASTRONY"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_2 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_2,tabela_nazw_2); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu: * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gn3p4o8jysgfy7du2ntrw28ost55fum 539825 539824 2026-04-14T15:20:31Z Persino 2851 /* Funkcja biblioteczna */ 539825 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw książkowe == === Funkcje nazw książki === ==== {{Code|m["NAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, bez przestrzeni nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}, a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż|użytkownik}}}}, gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local nazwa_ksiazki_1=nazwy_modul["NAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_ksiazki_2=nazwy_modul["NAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka: local nazwa_ksiazki_3=nazwy_modul["NAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_4=nazwy_modul["NAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik/Książka": local nazwa_ksiazki_5=nazwy_modul["NAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAKSIĄŻKI}}: * {{Code|{{s|NAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Jest to adres książki, do której należy podany artykuł, jako jego element, z przestrzenią nazw, ale z przestrzenią nazw książki, która dla przestrzeni: {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}}, jest pustym ciągiem, a z tą przestrznia nazw {{Code|Wikibooks'a}}, jedynie dla tej drugiej jest ciągiem niepustym, a dla niby-przestrzeni nazw: {{lr2|Brudnopis}}, przestrzenią nazw książki, z przestrzeniami projektu, jest: {{Code|{{lr2|Brudnopis/użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lr|Brudnopis/użytkownik}}}}), a dla przestrzeni: {{Np|User|link=tak}}, przestrzenią jego jest: {{Code|{{lż2|użytkownik}}}} (gdzie przestrzenią książki jest: {{Code|{{lż|użytkownik}}}}), gdzie zamiast nazwy {{Code|użytkownik}} należy wstawić nazwę użytkownika. Podobnie jest dla niby-przestrzeni: {{ls2|Brudnopis}} i {{ld2|Brudnopis}}. Dla innych przestrzeni jest jak dla przestrzeni {{Np|Wikijunior|link=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka": local pelna_nazwa_ksiazki_1=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior:Książka": local pelna_nazwa_ksiazki_2=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_3=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_4=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik/Książka": local pelna_nazwa_ksiazki_5=nazwy_modul["PEŁNANAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} === Funkcje nazw artykułów === ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości: "". <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Gdy nazwa artykułu jest równa stronie głównej podręcznika * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["NAZWAARTYKUŁUKSIĄŻKI2"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAARTYKUŁUKSIĄŻKI2}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jako podstrony książki przyporządkowanej jej. Jeżeli artykułem jest strona główna książki, to nazwa artykułu jest ciąg pusty o wartości równej nazwie sub-książki, czyli bez przestrzeni książki i projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "artykuł: local nazwa_artykulu_ksiazki_1=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_2=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_3=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_4=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "artykuł": local nazwa_artykulu_ksiazki_5=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_6=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_7=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_8=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_9=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local nazwa_artykulu_ksiazki_10=nazwy_modul["NAZWAARTYKUŁUKSIĄŻKI2"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAARTYKUŁUKSIĄŻKI2}}: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikijunior:Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{NAZWAARTYKUŁUKSIĄŻKI2|Moduł:Brudnopis/Użytkownik/Książka}}}} ==== {{Code|m["PEŁNANAZWAARTYKUŁUKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu jako nazwy strony jedynie jego adres z nazwą sub-książki. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; local strona_6 = "Książka"; local strona_7 = "Wikijunior:Książka"; local strona_8 = "Wikibooks:Brudnopis/Użytkownik/Książka"; local strona_9 = "Szablon:Brudnopis/Użytkownik/Książka"; local strona_10 = "Moduł:Brudnopis/Użytkownik/Książka"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; local tabela_nazw_6={}; local tabela_nazw_7={}; local tabela_nazw_8={}; local tabela_nazw_9={}; local tabela_nazw_10={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_1=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_2=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_3=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_4=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_5=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_5,tabela_nazw_5); ---- Zwraca wynik: "Książka/artykuł": local pelna_nazwa_artykulu_ksiazki_6=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_6,tabela_nazw_6); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_7=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_7,tabela_nazw_7); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_8=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_8,tabela_nazw_8); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_9=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_9,tabela_nazw_9); ---- Zwraca wynik: "Książka": local pelna_nazwa_artykulu_ksiazki_10=nazwy_modul["PEŁNANAZWAARTYKUŁUKSIĄŻKI"](strona_10,tabela_nazw_10); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} Artykuł równy głównej jej stronie: * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikijunior:Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka}}}} * {{Code|{{s|PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} → {{Tt|{{PEŁNANAZWAARTYKUŁUKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka}}}} === Przestrzenie książki w przestrzeniach nazw książkowych === ==== {{Code|m["NAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_1=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "": local nazwa_przestrzeni_ksiazki_2=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_3=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_4=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Brudnopis/Użytkownik": local nazwa_przestrzeni_ksiazki_5=nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|NAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{NAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} ==== {{Code|m["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"]()}} ==== ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Szablon wyodrębnia z pełnej nazwy artykułu przestrzeń nazw książki z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw ---- Zwraca wynik: "": local pelna_nazwa_przestrzeni_ksiazki_1=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikijunior": local pelna_nazwa_przestrzeni_ksiazki_2=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Wikibooks:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_3=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Szablon:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_4=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Moduł:Brudnopis/Użytkownik": local pelna_nazwa_przestrzeni_ksiazki_5=nazwy_modul["PEŁNANAZWAPRZESTRZENIKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI}}: * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{PEŁNANAZWAPRZESTRZENIKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje subnazw, nawet książkowe == === {{Code|m.NAZWASUBPODSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBPODSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, z przestrzenią nazw, jeżeli nazwa strony jest równa pełnej stronie korzenia strony, w innych przypadkach ona działa podobnie jak funkcja: {{Code|{{sr|#m.NAZWASUBSTRONY()|p=Nazwy - Tom IV}}}}. Posługuje się nazwą strony bezpośrednio w stanie surowym bez przekształcania inną funkcją w samej swojej definicji, ale można ręcznie przekształcać tę nazwę, podając odpowiednio w jej parametr. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBPODSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBPODSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBPODSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m.NAZWASUBSTRONY()}} === ===== Odpowiednik szablonowy ===== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASUBSTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. Jest bardzo podobna do szablonu {{s|NAZWASUBPODSTRONY}}. ===== Funkcja biblioteczna ===== Funkcja wyodrębnia subnazwę strony, z pełnej nazwy strony, bez przestrzeni nazw. Korzysta z funkcji {{Code|{{sr|#m.NAZWASUBPODSTRONY()|p=Nazwy - Tom IV}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWASUBSTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona 3": local nazwa_substrony_2 = nazwy_modul.NAZWASUBSTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy substrony z pełnej nazwy strony: * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWASUBSTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["SUBNAZWAKSIĄŻKI"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|SUBNAZWAKSIĄŻKI}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon wyodrębnia z pełnej nazwy artykułu nazwę sub-książki, do której należy ten artykuł. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); -- Tytuły stron książek local strona_1 = "Książka/artykuł"; local strona_2 = "Wikijunior:Książka/artykuł"; local strona_3 = "Wikibooks:Brudnopis/Użytkownik/Książka/artykuł"; local strona_4 = "Szablon:Brudnopis/Użytkownik/Książka/artykuł"; local strona_5 = "Moduł:Brudnopis/Użytkownik/Książka/artykuł"; -- Tabele nazw local tabela_nazw_1={}; local tabela_nazw_2={}; local tabela_nazw_3={}; local tabela_nazw_4={}; local tabela_nazw_5={}; -- Nazwy książek bez przestrzeni nazw i przestrzeni nazw książki: ---- Zwraca wynik: "Książka": local nazwa_subksiazki_1=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_2=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_2,tabela_nazw_2); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_3=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_3,tabela_nazw_3); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_4=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_4,tabela_nazw_4); ---- Zwraca wynik: "Książka": local nazwa_subksiazki_5=nazwy_modul["SUBNAZWAKSIĄŻKI"](strona_5,tabela_nazw_5); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady zastosowań szablonu {{s|SUBNAZWAKSIĄŻKI}}: * {{Code|{{s|SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikijunior:Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Wikibooks:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Szablon:Brudnopis/Użytkownik/Książka/artykuł}}}} * {{Code|{{s|SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} → {{Tt|{{SUBNAZWAKSIĄŻKI|Moduł:Brudnopis/Użytkownik/Książka/artykuł}}}} == Funkcje nazw korzeni stron == === {{Code|m.NAZWAKORZENIASTRONY()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Strona": local nazwa_substrony_1 = nazwy_modul.NAZWAKORZENIASTRONY(strona_1,tabela_nazw_1); ---- Zwraca wynik: "Strona": local nazwa_substrony_2 = nazwy_modul.NAZWAKORZENIASTRONY(strona_2,tabela_nazw_2); </syntaxhighlight> Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, bez przestrzeni nazw projektu: * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{NAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} === {{Code|m["PEŁNANAZWAKORZENIASTRONY"]()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|PEŁNANAZWAKORZENIASTRONY}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Funkcja wyodrębnia korzeń (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local strona_1 = "Wikibooks:Strona"; local strona_2 = "Wikibooks:Strona/Strona_1/Strona_2/Strona_3"; local tabela_nazw_1 = {}; local tabela_nazw_2 = {}; -- Wyodrębnianie nazwy substrony z pełnej nazwy strony: ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_1 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_1,tabela_nazw_1); ---- Zwraca wynik: "Wikibooks:Strona": local nazwa_substrony_2 = nazwy_modul["PEŁNANAZWAKORZENIASTRONY"](strona_2,tabela_nazw_2); </syntaxhighlight> ====== Przykłady użycia ====== Przykłady wyodrębniania nazwy korzenia (podstawę) strony, z pełnej nazwy strony, z przestrzenią nazw projektu: * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona}}}} * {{Code|{{s|PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} → {{Tt|{{PEŁNANAZWAKORZENIASTRONY|Wikibooks:Strona/Strona_1/Strona_2/Strona_3}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hz3kg3glwimrygtez3gnss6nde9urjf 4 63462 539803 539802 2026-04-14T12:13:03Z Persino 2851 /* {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} */ 539803 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;"; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> s8a0zw3ac7g2bxk07x7b50znhhhnfq9 539804 539803 2026-04-14T12:22:21Z Persino 2851 /* {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} */ 539804 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 616daef84bk43is0cywixqb64ccw1km 539805 539804 2026-04-14T12:42:27Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539805 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{html=html,}; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{args={html=html,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 8r6o5htkik5aufex12wxkipeib0fjq2 539806 539805 2026-04-14T12:52:04Z Persino 2851 539806 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{html=html,}; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{args={html=html,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7dls3arcogloq0ewuh4ig49349a9x63 539807 539806 2026-04-14T12:56:24Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539807 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{html=html,}; -- Równoważne: local html2=html_modul.ZnakiSpecjalneWikiLinku{args={html=html,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bfei8vvhivjllgic6cm6nlireuo6zpx 539808 539807 2026-04-14T12:57:40Z Persino 2851 /* {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} */ 539808 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 4fxnjzmo04s6erj147g9hzphvutgxcx 539809 539808 2026-04-14T13:01:01Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539809 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7g87uw7q01pvsfukwgozda30t6wkwvg 539810 539809 2026-04-14T13:01:52Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539810 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>%[%]#=%?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cteazadmmwhwtwo8l3ya5mid0ltbhhn 539811 539810 2026-04-14T13:02:25Z Persino 2851 /* {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} */ 539811 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> b027vrj3eozaw4dv91fa0uflo9az396 539812 539811 2026-04-14T13:03:54Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539812 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów i nagłówka na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ne1sw4wv7l518j395oq9mgweim86y5g 539814 539812 2026-04-14T13:08:22Z Persino 2851 /* {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} */ 539814 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym końcu) na specjalne kody {{Strong|HTML}}, aby były one odróźnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> l60hs1583oujec3lsw7vhv8fwk6qsoy 539815 539814 2026-04-14T13:09:31Z Persino 2851 /* {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} */ 539815 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> oy2cew15xgdplnh6nyuzyik1a7ms077 539816 539815 2026-04-14T13:13:09Z Persino 2851 /* {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} */ 539816 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html=[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 750s6o2qpl5hunris6xcjuwco64bhtu 539818 539816 2026-04-14T13:22:30Z Persino 2851 539818 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> no832z8tmdpavcufmsa8ak1yl8lvm7t 539819 539818 2026-04-14T14:11:27Z Persino 2851 /* {{Code|p.EncodeZnakProloguList(frame)}} */ 539819 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. on jest określany przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem, a więc ten szablon służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local html2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> khce8q9jt8uvlafvwmp2drttihtwz4t 539820 539819 2026-04-14T14:12:32Z Persino 2851 /* {{Code|p.EncodeZnakProloguList(frame)}} */ 539820 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. on jest określany przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem, a więc ten szablon służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kvwpimetnsj9wxnz9jm5ji05eff84ls 539826 539820 2026-04-14T15:57:57Z Persino 2851 /* {{Code|p.EncodeZnakProloguList(frame)}} */ 539826 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. on jest określany przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem, a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 4ulouv2t8qhqil4o5u2sl07dti7ovdy 539827 539826 2026-04-14T16:16:53Z Persino 2851 /* {{Code|p.EncodeZnakProloguList(frame)}} */ 539827 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez szablon), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> r2sruala79a5esuourlxoxacuxd9t6l 539828 539827 2026-04-14T16:17:39Z Persino 2851 /* {{Code|p.EncodeZnakProloguList(frame)}} */ 539828 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 41hs3ojeecmsibxuofwu8woybq4dsn0 539882 539828 2026-04-15T06:34:26Z Persino 2851 /* {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} */ 539882 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 49m058infdfae1um5rwkm77w38hpe13 539883 539882 2026-04-15T06:38:37Z Persino 2851 /* {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} */ 539883 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> er3dowdaauots9c8rwofta2nlkw0et6 539884 539883 2026-04-15T06:43:14Z Persino 2851 /* {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} */ 539884 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> o4z7xr0yfhw7g1mwc0jg6zxis7u9ydg 539885 539884 2026-04-15T06:56:42Z Persino 2851 /* {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} */ 539885 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p.Rozwiń(frame)|p=Ramka}}}}, do rozwijania parametrów. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2y87beo1yzejstwm75op3c9rra6ajha 539886 539885 2026-04-15T06:57:24Z Persino 2851 /* {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} */ 539886 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> a2zgyv0q8mhu9ynm5ne45x4jxo327vy 539887 539886 2026-04-15T06:58:09Z Persino 2851 /* {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} */ 539887 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> toomkpqws4ifeat1wzcm3f21vyzy10s 539888 539887 2026-04-15T07:04:18Z Persino 2851 /* {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} */ 539888 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> t12meexgxt5jem47k9k7m0vc6t6altb 539889 539888 2026-04-15T07:35:05Z Persino 2851 /* {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} */ 539889 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fhnkqb0lhodls5bk620n5o6rbi14rzn 539890 539889 2026-04-15T07:40:53Z Persino 2851 539890 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> et730uslg6fsdb377tbh2zrfkapv41c 539891 539890 2026-04-15T07:43:12Z Persino 2851 /* {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} */ 539891 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nb3xdb4psge1yl6szxjr2u1bsp7bb5y 539899 539891 2026-04-15T09:55:57Z Persino 2851 /* {{Code|p.KodHTMLZnaku(frame)}} */ 539899 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> t9p22omkw0o65sp4usx0e0nxqhbn0k0 539900 539899 2026-04-15T09:57:13Z Persino 2851 /* {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} */ 539900 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 6cto5j8ztn2rlt0jyhbta6my8pgqg36 539901 539900 2026-04-15T10:24:57Z Persino 2851 /* Funkcja biblioteczna */ 539901 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}.. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; local tekst3=html_modul.KodHTMLZnaku(znak); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;#107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;#107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> k8n6gximeul3fgsak9rjs0ml5jc5gjj 539902 539901 2026-04-15T10:36:49Z Persino 2851 /* Funkcja biblioteczna */ 539902 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}.. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;#107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;#107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ttj4xckgc6787dj8ku85jhldtnruyag 539903 539902 2026-04-15T10:37:37Z Persino 2851 /* Funkcja biblioteczna */ 539903 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}.. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;#107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;#107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> qf9qxhjl15wgc6sy5i0hxzw9o4dh2cc 539904 539903 2026-04-15T10:51:24Z Persino 2851 /* Funkcja biblioteczna */ 539904 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;#107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;#107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> mssmvj8gqwuhhslsa8uwwhboq7gxrq2 539911 539904 2026-04-15T11:41:49Z Persino 2851 /* Funkcja biblioteczna */ 539911 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;&num;107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;&num;107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> b6wyyxueexvsc5lr5jyixxb229ny5aj 539912 539911 2026-04-15T11:44:11Z Persino 2851 /* Funkcja biblioteczna */ 539912 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Html}}|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 html_modul=require("Module:Html"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł zawiera funkcje do posługiwania się kodami {{Strong|HTML}}, zamieniania znaków na ich kody, i odwrotnie. Kodowaniem i dekodowaniem {{Strong|URL}} adresów internetowych, parametrów i nagłówków. Rozdzielaniem pełnych adresów na nazwę strony, zapytanie i nagłówek, odpowiednich ich kodowaniem, a potem ich łącznie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>|[]()+-*?.^$%'</nowiki>}}. Jest ona potrzebna do zamiany nazw stron nazw wewnętrznych na {{NAZWASERWISU|link=tak}}, a w nich te znaki na kody {{Code|HTML}}, by wykorzystać później to w funkcji: {{Code|mw.title.makeTitle}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKlasyZnakowejDoKoduHtmlCiągu|tekst=Oto jest link: [[user:użytkownik|(Użytkownik)]].}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; </syntaxhighlight> == {{Code|p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)}} == Zamienia w tekście znaki kodów {{Strong|HTML}} dziesiętne i szesnastkowe na odpowiednie znaki {{Strong|Unicode}}. Kody dziesiętne oznaczone są wyrażone wyrażeniem regularnym {{Code|<nowiki>&#(%d+);</nowiki>}}, a szesnastkowe: {{Code|<nowiki>&#x(%x+);</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TransformacjaKoduHtmlDoZnakuCiągu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|TransformacjaKoduHtmlDoZnakuCiągu|tekst=Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest link: &#91;&#91;user:użytkownik&#124;&#40;Użytkownik&#41;&#93;&#93;&#46;"; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{tekst=tekst,}; -- Równoważne: local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"]{args={tekst=tekst,},}; local tekst2=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w zawartości pomiędzy tagami tagu {{Tag|nowiki}} (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}}), wikikodu na kody {{Strong|HTML}}. Zamieniane znaki to są podane w nawiasach kwadratowych w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a przed tym znakiem jest zwykle {{Code|<nowiki>%</nowiki>}}, jeżeli to nie jest znak specjalny wyrażeń regularnych w nim, a te znaki zamieniane to są: {{Code|<nowiki>!{}|=<>[]</nowiki>}}. Dlatego te znaki, bo {{Code|<nowiki>=<>[]</nowiki>}} są częścią tagów mechanizmu {{Strong|HTML}}, a w tagach mogą być też linki wewnętrzne, czy zewnętrzne, i nierozwinięte szablony, a więc też i {{Code|<nowiki>{}|</nowiki>}}, a elementy {{Code|<nowiki>!{}|=</nowiki>}} są one częścią wiki-tabelek mechanizmu {{Code|MediaWiki}}, elementy te też mogą występować, gdzieś indziej w tekście w wikikodzie, również ze znakiem {{Code|<nowiki>=</nowiki>}} i z innymi tutaj wspomnianymi znakami tagowymi, też trzeba je zakodować nimi. Tak je kodujemy przez tę funkcję, by tak uzyskany tekst nie miał elementów mechanizmu {{Strong|HTML}}, ani {{Strong|MediaWiki}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneTaguNowiki(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneTaguNowiki|tekst=<span id="toc">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>.}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"toc\">Oto jest tekst, i link: [[Pomoc:Spis treści|Spis treści]]</span>."; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneTaguNowiki{args={tekst=tekst,},}; local tekst2=html_modul.ZnakiSpecjalneTaguNowiki(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#60;span id&#61;\"toc\"&#62;Oto jest tekst, i link: &#91;&#91;Pomoc:Spis treści&#124;Spis treści&#93;&#93;&#60;/span&#62;."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneWikiLinku(frame)}} == Zamienia znaki specjalne transformacji nagłówka adresów '''HTML''' (nagłówek zaczyna się od znaku {{Code|<nowiki>#</nowiki>}} - na samym końcu, w adresach stron, ale na samym początku w nich) na specjalne kody {{Strong|HTML}}. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneWikiLinku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZnakiSpecjalneWikiLinku|tekst={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZnakiSpecjalneWikiLinku{args={tekst=tekst,},}; local html2=html_modul.ZnakiSpecjalneWikiLinku(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1=wartość1&#124;parametr 2=wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeSpecjalneZnakiHtml(frame)}} == Zamienia znaki specjalne adresu strony, jego parametrów (bez {{Code|<nowiki>?</nowiki>}} - wskazującej na początek adresu strony z parametrami, {{Code|<nowiki>&</nowiki>}} - oddzielające zmienne i ich wartości, {{Code|<nowiki>=</nowiki>}} - oddzielającej parametr od jej wartości w zmiennej) i nagłówka (bez {{Code|<nowiki>#</nowiki>}} na samym początku) na specjalne kody {{Strong|HTML}}, aby były one odróżnialne od innych specjalnych znaków adresów '''HTML'''. Do tego celu wykorzystuje znaki {{Code|<nowiki>{}|<>[]#=?&</nowiki>}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeSpecjalneZnakiHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeSpecjalneZnakiHtml|html={{#invoke:Łatki|unstripNoWiki|tekst=<nowiki>[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}</nowiki>}}}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|html2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local html="[pl] Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: {{Szablon do używania|parametr 1=wartość1|parametr 2=wartość2}}"; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{html=html,}; -- Równoważne: local html2=html_modul.EncodeSpecjalneZnakiHtml{args={html=html,},}; local html2=html_modul.EncodeSpecjalneZnakiHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local html2="&#91;pl&#93; Strony z nagłówkiem (mechanizmu HTML), a w nim jest szablon: &#123;&#123;Szablon do używania&#124;parametr 1&#61;wartość1&#124;parametr 2&#61;wartość2&#125;&#125;"; </syntaxhighlight> == {{Code|p.EncodeZnakProloguList(frame)}} == Szablon zamienia pierwszy znak wiki-listy (więc znak po {{Code|<nowiki>\n</nowiki>}}), tzn. znaki z: {{Code|<nowiki>#*;:</nowiki>}} na kod {{Strong|HTML}}, a znak bezpośrednio na samym początku od pewnego momentu, tzn. ten znak jest po znaku lub początku określanym przez wyrażenie regularne: {{Code|<nowiki>^\n?</nowiki>}}, ten znak wiki-listy zamieniany jest na ten kod, a początkowy znak nowej linii, jeżeli istnieje, jest usuwany. To jest przyszykowane po to, gdyby w szablonie pierwszy wygenerowany znak, był tym znakiem listy (wtedy mechanizm {{Strong|MediaWiki}} generuje bezpośrednio przed nim znak nowej linii, który jest na początku łańcucha wygenerowany przez to), a więc ta funkcja służy też do tego. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZnakProloguList(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|EncodeZnakProloguList|tekst= * Oto jest pierwszy element listy, *: Oto jest drugi element listy. }} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="\n* Oto jest pierwszy element listy,\n*: Oto jest drugi element listy."; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.EncodeZnakProloguList{args={tekst=tekst,},}; local tekst2=html_modul.EncodeZnakProloguList(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#42; Oto jest pierwszy element listy,\n&#42;: Oto jest drugi element listy."; </syntaxhighlight> == {{Code|p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, bez parametrów, a parametry, tam gdzie one nie mogą występować, a jednak występują, opisujące parametry, tzn. od czego zaczynają się one, jak są one oddzielone, jak oddzielone są nazwy od ich wartości w przypadku parametru. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ParametryPrzypisaniaZnakowegoEncodeHtml|tekst=Wikibooks:Strona?action=edit&section=2}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona?action=edit&section=2"; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.ParametryPrzypisaniaZnakowegoEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#63;action&#61;edit&#38;section&#61;2"; </syntaxhighlight> == {{Code|p.PrzypisanieZnakoweEncodeHtml(frame)}} == Eliminuje znaki specjalne nazw stron, oddzielające nazwy parametrów od ich wartości, aby jak dana zmienna jest nienazwana (numerowana), aby nie była traktowana jako nazwana ze względu na występowanie znaku równości {{Code|{{=}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PrzypisanieZnakoweEncodeHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|PrzypisanieZnakoweEncodeHtml|tekst=Wikibooks:Strona=Parametry}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Wikibooks:Strona=Parametry"; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml{args={tekst=tekst,},}; local tekst2=html_modul.PrzypisanieZnakoweEncodeHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="Wikibooks:Strona&#61;Parametry"; </syntaxhighlight> Użycie w szablonie w postaci parametry nienazwanego (numerowanego): <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona=Parametry}} </syntaxhighlight> może powodować pewne problemy, ta zmienna nie zostanie nazwana jako nienazwana, tylko jako nazwana o nazwie parametru {{Code|Wikibooks:Strona}} i wartości {{Code|Parametry}}. Aby tego uniknąć, wypadałoby napisać to wywołanie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|Wikibooks:Strona&#61;Parametry}} </syntaxhighlight> Wtedy to zostanie na pewno zostanie potraktowane jako zmienna nienazwana (numerowana). Szczególnie to jest ważne, gdy używamy funkcji: {{Code|{{sr|#p["Rozwiń"](frame)|p=Ramka}}}}, do rozwijania parametrów. W takim przypadku trzeba używać funkcji: {{Code|{{sr|#p.PrzypisanieZnakoweEncodeHtml(frame)|p=Html}}}}, aby zamienić przypisanie na parametr numerowany. == {{Code|p.ZamianaDwukropkaNaKodHtml(frame)}} == Zamienia dwukropki na kody {{Strong|HTML}}, tam gdzie one mają specjalne znaczenie, a po wyeliminowaniu ich (po zamianie) tracą owe znaczenie. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaDwukropkaNaKodHtml(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje tekst do zamiany na kody klasy znakowej do kodu {{Strong|HTML}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument. Funkcja może też być wywołane w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} wikikodu w szablonie: <syntaxhighlight lang="mediawiki"> {{#invoke:Html|ZamianaDwukropkaNaKodHtml|tekst=subst:msg:Szablon:Nazwa_strony}} </syntaxhighlight> Wynikiem tego jest wartość, której odpowiada wartość zmiennej ukrytej pod nazwą {{Code|tekst2}} poniżej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="subst:msg:Szablon:Nazwa_strony"; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{tekst=tekst,}; -- Równoważne: local tekst2=html_modul.ZamianaDwukropkaNaKodHtml{args={tekst=tekst,},}; local tekst2=html_modul.ZamianaDwukropkaNaKodHtml(tekst); </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="subst&#58;msg&#58;Szablon&#58;Nazwa_strony"; </syntaxhighlight> == {{Code|p.KodHTMLZnaku(frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodHTMLZnaku}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === Zamienia zadany znak na kod {{Strong|HTML}}, wedle podanych parametrów lub po zamianie znak {{Code|{{Nowiki|&}}}} jest zamieniany na {{Code|{{Nowiki|&amp;}}}} i {{Code|{{Nowiki|#}}}} na {{Code|{{Nowiki|&num;}}}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodHTMLZnaku(frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - zmienna, pod którym jest znak do zamiany na kod {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}. Jeżeli funkcja znalazła tablicę ramki {{Code|frame.args}}, to wyszukuje w niej parametry, a jeżeli nie, to w {{Code|frame}}, a jeśli frame nie jest tabelką, tylko tekstem, to to zwraca jej zawartość tylko za pierwszym razem, a za drugim razem już {{Code|nil}}, a ta funkcja w takim przypadku raz wyszukuje ten argument, ale wtedy musi być podany parametr {{Parametr|wyspecjalizowana|tak}}, gdy mamy zmienną {{Code|frame.args}}, a jeżeli ten argument nie został podany z wartością niepustą, wtedy są wyszukiwane elementy z {{Code|frame:getParent().args}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local znak="k"; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{[1]=znak,}; -- Równoważne: local tekst2=html_modul.KodHTMLZnaku{args={[1]=znak,},}; local tekst2=html_modul.KodHTMLZnaku(znak); -- Równoważne: local tekst3=html_modul.KodHTMLZnaku{[1]=znak,[1]="tak",}; local tekst3=html_modul.KodHTMLZnaku{args={[1]=znak,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="&#107;"; local tekst3="&amp;&num;107;"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodHTMLZnaku|k}}}} → {{Tt|{{KodHTMLZnaku|k}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k}}}}}} * {{Code|{{s|KodHTMLZnaku|k|tak}}}} → {{Tt|{{KodHTMLZnaku|k|tak}}}} * {{Code|{{s|Nowiki|{{s|KodHTMLZnaku|k|tak}}}}}} → {{Tt|{{Nowiki|{{KodHTMLZnaku|k|tak}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "&#107"; --> {{#invoke:Html|KodHTMLZnaku|k|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "&amp;&num;107"; --> {{#invoke:Html|KodHTMLZnaku|k|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p["KodyHTMLZnakówWikiCiągu"](frame)}} == === Odpowiednik szablonowy === Odpowiednik szablonowy jest pod nazwą {{s|KodyHTMLZnakówWikiCiągu}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. === Funkcja biblioteczna === == {{Code|p.EncodeId(...)}} == == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == == {{Code|p.EncodeWiki(...)}} == == {{Code|p.DecodeWiki(...)}} == == {{Code|p.IsEncodedHtml(...)}} == == {{Code|p.EncodeHtml(...)}} == == {{Code|p.DecodeHtml(...)}} == == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == == {{Code|p["ParametryStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyAdresu"](frame,...)}} == == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == == {{Code|p["URLStrona"](frame)}} == == {{Code|p["UrlBezProtokołu"](frame)}} == == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == == {{Code|p.ZamianaEncodeTekst(tekst)}} == == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == == {{Code|p.StronaParametryIdentyfikacja(adres)}} == == {{Code|p.TworzenieAdresuHtml(strona,...)}} == == {{Code|p.TworzenieStronaParametryIdentyfikacja(adres,...)}} == == {{Code|p.ParametryEncodeURL(adres,...)}} == == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == == {{Code|p.EncodeParametryHtml(parametr,...)}} == == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == == {{Code|p.AdresBezProtokolarnyEncodeURL(adres)}} == == {{Code|p.UriEncode(frame)}} == == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jqghc5k5aiyorjpamvrd7v195gocs1d 0 63467 539830 539768 2026-04-14T16:35:10Z Persino 2851 539830 wikitext text/x-wiki {{Podrozdział|Podręcznik|[[Życie codzienne]]<br>Livehacki}} ==== Zapachy w mieszkaniu ==== * W ognioodpornym naczyniu powoli spalaj suszony liść laurowy, by dym przeszkadzał owadom wchodzić do mieszkania. ==== Kąpiel ==== * Do kąpieli przed snem wrzuć kilka liści laurowych, które działają rozluźniająco. ==== Szafki kuchenne ==== * Do słoja z mąką, kaszą itp. wrzuć liść laurowy - szkodniki nie lubią jego zapachu. ==== Szafy ubraniowe ==== * Do szafy wrzuć kilka liści laurowych - szkodniki nie lubią jego zapachu. 4j5x7iarkub35vha7fwxj4ktrl88quu 0 63469 539813 539787 2026-04-14T13:06:26Z EdytaT 2664 539813 wikitext text/x-wiki {{Podrozdział|[[Zioła i przyprawy]]|Wawrzyn szlachetny (liść laurowy)}} [[Plik:Laurus nobilis (5).JPG|thumb|Liście laurowe]] {{wikipedia|Wawrzyn szlachetny}} {{wikipedia|Liść laurowy}} {{wikisłownik|wawrzyn szlachetny}} {{wikisłownik|Liść laurowy}} {{Wikibooks|Ekoogrodnictwo/Rośliny użytkowe/Wawrzyn szlachetny|wawrzynu szlachetnego}} == Wawrzyn szlachetny (liść laurowy) == == Liście laurowe == * Zarówno świeże jak i suszone liście laurowe można dodać do potraw. * Pod względem smaku liście świeże i suszone znacznie się od siebie różnią. * Świeże liście smakują intensywniej, gorzko-pikantnie oraz zawierają więcej [[w:Garbniki|garbników]]. Należy je stosować umiarkowanie - często wystarczy połowa świeżego liścia zamiast jednego-dwóch suszonych. === Potrawy === * Wywary warzywne, mięsne, rybne * Zupy * Potrawy duszone == Przypisy == {{Przypisy}} {{BrClear}} <noinclude>{{Wolumin}}</noinclude> 07wq23b845d06zgplsuwabnpl3zz9h0 3 63470 539870 2026-04-14T19:21:49Z Persino 2851 Utworzono nową stronę "{{Witaj}} ~~~~" 539870 wikitext text/x-wiki {{Witaj}} [[Wikipedysta:Persino|Persino]] ([[Dyskusja wikipedysty:Persino|dyskusja]]) 21:21, 14 kwi 2026 (CEST) dfkrwckt2tqxqjn1wu8sw1fu3q5mrdy